为啥输出随机数？

#include <bits/stdc++.h>

#define int long long
#define up(i ,x ,y) for(int i = x ; i <= y ; i ++)
#define dn(i ,x ,y) for(int i = x ; i >= y ; i --)
#define inf 1e18

using namespace std;

inline int read(){int x = 0 ; char c = getchar() ; bool w = 0 ; while(!isdigit(c)){w |= (c == '-') ,c = getchar() ; } while(isdigit(c)) {x = (x << 1) + (x << 3) + (c ^ 48) ,c = getchar() ;} return w ? -x : x;}
inline void write(int x){if(x < 0) x = ~(x + 1) ,putchar('-') ; if(x > 9) write(x / 10) ; putchar(x % 10 | 48);}
inline void writesp(int x){write(x) ,putchar(' ');}
inline void writeln(int x){write(x) ,putchar('\n');}

const int N = 1e5 + 10 ,mod = 1e9 + 7;
int n ,ans ,b[N] ,tr[N]; 
int sums ,c[N];

namespace lolcrying {

	struct node {int x , y ,yz;} a[N];
	inline int qpow(int a ,int b ,int p) {
		int res = 1;
		for( ; b ; a = a * a % p ,b >>= 1) if(b & 1) res = res * a % p;
		return res;
	} inline bool cmp(node x ,node y) {return x.x == y.x ? x.y < y.y : x.x < y.x; }

	#define lowbit(i) (i & -i)
	inline void add(int x ,int v) {for(int i = x ; i <= 1e5 ; i += lowbit(i)) tr[i] += v;}
	inline int query(int x){int res = 0 ; for(int i = x ; i ; i -= lowbit(i)) res += tr[i] ; return res;}

	struct FHQ {
		int rt = 0 ,idx = 0 ,mul[N] ,sz[N] ,sum[N] ,val[N] ,ls[N] ,rs[N] ,pri[N];
		inline void pushup(int u) {
			sz[u] = sz[ls[u]] + sz[rs[u]] + 1 ;
			sum[u] = sum[ls[u]] + sum[rs[u]] + val[u] ,sum[u] %= mod;
		} inline void pushdown(int u) {
			if(mul[u] ^ 1) {
				int Mul = mul[u];
				if(ls[u]) {
					sum[ls[u]] *= Mul ,sum[ls[u]] %= mod;
					mul[ls[u]] *= Mul ,mul[ls[u]] %= mod;
				} if(rs[u]) {
					sum[rs[u]] *= Mul ,sum[rs[u]] %= mod;
					mul[rs[u]] *= Mul ,mul[rs[u]] %= mod; 
				} mul[u] = 1;
			}	
		} inline int newnode(int v){ return val[++ idx] = v ,pri[idx] = rand() ,sz[idx] = 1 ,sum[idx] = v ,mul[idx] = 1 ,idx;}

		inline void split(int u ,int v ,int &x ,int &y) {
			if(!u) {x = y = 0 ; return ;}
			int t = sz[ls[u]];
			pushdown(u);
			if(t < v) {
				x = u ; 
				split(rs[u] ,v - t - 1 ,rs[x] ,y) ;
			} else {
				y = u ; 
				split(ls[u] ,v ,x ,ls[y]);
			} pushup(u);
		}

		inline int merge(int u ,int v) {
			if(!u || !v) return u | v;
			if(pri[u] < pri[v]) {
				pushdown(u);
				rs[u] = merge(rs[u] ,v);
				pushup(u);
				return u ;
			} else {
				pushdown(v);
				ls[v] = merge(u ,ls[v]);
				pushup(v);
				return v;
			}
		}

		inline void insert(int p ,int v){
			int z = newnode(v) ,x ,y; 
			split(rt ,p - 1 ,x ,y);
			rt = merge(merge(x ,z) ,y);
		} inline void muls(int l ,int r) {
			int x ,y ,z;
			split(rt ,r ,x ,y);
			split(x ,l - 1 ,x ,z);
			mul[z] *= 2 ,sum[z] *= 2 ,val[z] *= 2 ,val[z] %= mod ,sum[z] %= mod ,mul[z] %= mod;
			rt = merge(merge(x ,z) ,y);
		} inline int get(int l ,int r) {
			if(l > r) return 0 ; 
			int x ,y ,z;
			split(rt ,r ,x ,y);
			split(x ,l - 1 ,x ,z);
			int ans = sum[z] ; 
			rt = merge(merge(x ,z) ,y);
			return ans;
		}
	} tr;

	inline bool cmp0(node x ,node y) {return x.y == y.y ? x.x < y.x : x.y < y.y;}

	signed main(){

		srand(time(NULL));
		n = read();
		up(i ,1 ,n) a[i].x = read() ,a[i].y = read();
		sort(a + 1 ,a + 1 + n ,cmp0);
		up(i ,1 ,n) a[i].yz = i ;
		up(i ,1 ,n) tr.mul[i] = 1;

		sort(a + 1 ,a + 1 + n ,cmp);

		up(i ,1 ,n) {

			int c = qpow(2 ,a[i].x ,mod) ;

			int three = 0 ,pos = query(a[i].yz);

			three = qpow(2 ,pos ,mod) * qpow(3 ,a[i].y ,mod) % mod ; 
			three += tr.get(pos + 1 ,i - 1) ,three %= mod; 

//			up(j ,pos + 1 ,i - 1)
//				three += qpow(2 ,j - 1 ,mod) * qpow(3 ,b[j] ,mod) % mod ,three %= mod;

			ans += c * three % mod ,ans %= mod;

			add(a[i].yz ,1);
			tr.insert(pos + 1 ,qpow(2 ,pos ,mod) * qpow(3 ,a[i].y ,mod) % mod);
			tr.muls(pos + 2 ,i);

//			b[i] = a[i].y;
//			dn(j ,i - 1 ,pos + 1) b[j + 1] = b[j];
//			b[pos + 1] = a[i].y;

		}

		writeln(ans);

		return 0 ;
	} 
} signed main(){
	freopen("lcms.in" ,"r" ,stdin);
	freopen("lcms.out" ,"w" ,stdout);
	
	int T = 1;
	while(T --) lolcrying :: main();
	
	return 0 ;
}