#include <iostream>
#include <vector>
using namespace std;

const int MOD = 1e9 + 7;

class SegmentTree {
    int n;
    vector<long long> t;
    bool isSum;

public:
    SegmentTree(const vector<int>& v, bool sum) : n(v.size()), isSum(sum) {
        t.resize(2 * n, sum ? 0 : 1);
        for (int i = 0; i < n; ++i) {
            t[i + n] = v[i];
        }
        for (int i = n - 1; i > 0; --i) {
            t[i] = isSum ? (t[2 * i] + t[2 * i + 1]) % MOD : (t[2 * i] * t[2 * i + 1]) % MOD;
        }
    }

    long long query(int l, int r) {
        long long res = isSum ? 0 : 1;
        l += n;
        r += n;
        while (l < r) {
            if (l & 1) {
                res = isSum ? (res + t[l]) % MOD : (res * t[l]) % MOD;
                ++l;
            }
            if (r & 1) {
                --r;
                res = isSum ? (res + t[r]) % MOD : (res * t[r]) % MOD;
            }
            l /= 2;
            r /= 2;
        }
        return res;
    }
};

vector<long long> HardQueries(int n, const vector<int>& v, int q, const vector<vector<int>>& queries) {
    vector<long long> ans;
    SegmentTree sumTree(v, true);
    SegmentTree prodTree(v, false);

    for (const auto& x : queries) {
        int type = x[0], a = x[1] - 1, b = x[2];
        vector<int> indices;
        for (int i = a; i < n; i += b) {
            indices.push_back(i);
        }

        if (type == 0) {
            long long res = 0;
            for (int idx : indices) {
                res = (res + sumTree.query(idx, idx + 1)) % MOD;
            }
            ans.push_back(res);
        } else if (type == 1) {
            long long res = 1;
            for (int idx : indices) {
                res = (res * prodTree.query(idx, idx + 1)) % MOD;
            }
            ans.push_back(res);
        }
    }

    return ans;
}