Untitled

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

#define all(a) a.begin(), a.end()
#define allr(a) a.rbegin(), a.rend()
#define endl '\n'

const int N = 1e4 + 5;
vector<int> spf(N), gpf(N, 1), sm(N);
void sieve() {
    for (int i = 2; i < N; i++) {
        if (spf[i] == 0) {
            for (int j = i; j < N; j += i) {
                if (spf[j] == 0)
                    spf[j] = i;
            }
        }
    }
    
    for (int i=2; i<N; i++) {
        int x = i;
        while (x > 1) {
            sm[i] += spf[x];
            gpf[i] = spf[x];
            x /= spf[x];
        }
    }
}

struct node {
    int val = 0, ans = 0, lazy = 0;
};

struct segTree {
    vector<node>Tree;
    int sz;
    
    void propagate(int p, int s, int e) {
        if (Tree[p].lazy == 0) return;
        if (s != e) {
            Tree[2*p].lazy = Tree[2*p+1].lazy = Tree[p].lazy;
        }
        Tree[p].val = Tree[p].lazy;
        Tree[p].ans = sm[Tree[p].lazy] * (e - s + 1);
        Tree[p].lazy = 0;
    }

    void update(int p, int s, int e, int l, int r, int x) {
        propagate(p, s, e);
        if (l > e || s > r) return;
        if (s>=l && e<=r) {
            Tree[p].lazy = x;
            propagate(p, s, e);
            return;
        }
        int mid = (s + e) / 2;
        update(2*p, s, mid, l, r, x);
        update(2*p+1, mid+1, e, l, r, x);
        Tree[p].ans = Tree[2*p].ans + Tree[2*p+1].ans;
    }

    pair<ll, int> query(int p, int s, int e, int l, int r) {
        propagate(p, s, e);
        if (l > e || s > r) return {0LL, 0}; 
        if (s >= l && e <= r) return {Tree[p].ans, Tree[p].val};
        int mid = (s + e) / 2;
        auto lf = query(2 * p, s, mid, l, r), rg = query(2 * p + 1, mid + 1, e, l, r);
        return {lf.first + rg.first, max(lf.second, rg.second)};
    }
    
    
    int query(int l, int r) {
        return query(1, 0, sz-1, l, r).first;
    }
    
    void update1(int l, int r, int x) {
        update(1, 0, sz-1, l, r, x);
    }
    
    void update2(int idx) {
        int val = query(1, 0, sz-1, idx, idx).second;
        update1(idx, idx, val / gpf[val]);
    }

    segTree(int n) {
        sz = n;
        Tree.resize(4 * n);
    }
};

void solve() {
    int n;
    cin >> n;
    segTree tree(n);
    for (int i=0; i<n; i++) {
        int x;
        cin >> x;
        tree.update1(i, i, x);
    }

    int q;
    cin >> q;
    while (q--) {
        int op;
        cin >> op;
        if (op == 1) {
            int idx;
            cin >> idx; idx--;
            tree.update2(idx);
        }
        else if (op == 2) {
            int l, r;
            cin >> l >> r;
            l--; r--;
            cout << tree.query(l, r) << endl;
        }
        else {
            int l, r, x;
            cin >> l >> r >> x;
            l--; r--;
            tree.update1(l, r, x);
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    sieve();
    int t = 1;
    // cin >> t;
    while (t--) solve();
}