Untitled

const int B = 280;
const int MOD = 1000000007;

long long powMod(long long x, int y) {
    long long z = 1;
    for (; y; y >>= 1) {
        if (y & 1) z = z * x % MOD;
        x = x * x % MOD;
    }
    return z;
}

long long inv(long long x) {
    return powMod(x, MOD - 2);
}

const int N = 100007;

long long sum[B][N];

class Solution {
public:
    int xorAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {
        int n = nums.size();
        for (int i = 1; i < B; ++i) {
            for (int j = 0; j < n; ++j) {
                sum[i][j] = 1;
            }
        }

        for (auto& query : queries) {
            int l = query[0];
            int r = query[1];
            int k = query[2];
            int v = query[3];

            if (k >= B) {
                int idx = l;
                while (idx <= r) {
                    nums[idx] = 1LL * nums[idx] * v % MOD;
                    idx += k;
                }
            } else {
                r = l + (r - l) / k * k;
                sum[k][l] = sum[k][l] * v % MOD;
                if (r + k < n) {
                    sum[k][r + k] = sum[k][r + k] * inv(v) % MOD;
                }
            }
        }

        for (int i = 1; i < B; ++i) {
            for (int j = 0; j < n; ++j) {
                if (j - i >= 0) {
                    sum[i][j] = sum[i][j] * sum[i][j - i] % MOD;
                }
            }
        }

        long long ans = 0;
        for (int i = 0; i < n; ++i) {
            long long cur = nums[i];
            for (int j = 1; j < B; ++j) {
                cur = cur * sum[j][i] % MOD;
            }
            ans ^= cur;
        }
        return ans;
    }
};