#include <vector>
#include <utility>
#include <fstream>
#include <iostream>

struct Tree {
    std::vector<std::pair<int, int>> Data;
    Tree(std::vector<int> &inp) {
        unsigned t = 1;
        for (; t <= inp.size(); t*=2);
        t*=4;
        Data = std::vector<std::pair<int, int>>(t, {0, 0});
        BuildTree(1, 1, inp.size(), inp);
    }
    int sum(int x, int len) {
        return x * len + len*(len-1)/2;
    }
    void push(int vr, int tl, int tr) {
        if (Data[vr].second == 0) {
            return;
        }
        int len = tr - tl + 1;
        int mid = (tl + tr)/2;
        int l1 = mid - tl + 1;
        Data[2*vr].first = sum(Data[vr].second, l1);
        Data[2*vr + 1].first = sum(Data[vr].second + l1, len - l1);
        Data[2*vr].second = Data[vr].second;
        Data[2*vr+1].second = Data[vr].second + l1;
        Data[vr].second = 0;
        return;
    }
    int BuildTree(int vr, int tl, int tr, std::vector<int> &inp) {
        if (tl > tr) {
            return 0;
        }
        if (tl == tr) {
            Data[vr].first = inp[tl-1];
            return Data[vr].first;
        }
        int mid = (tl + tr)/2;
        Data[vr].first = BuildTree(vr*2, tl, mid, inp) + BuildTree(vr*2 + 1, mid + 1, tr, inp);
        return Data[vr].first;
    }
    int Get(int vr, int tl, int tr, int l_, int r_) {
        if ((l_>r_)||(tl > tr)) {
            return 0;
        }
        push(vr, tl, tr);
        if (tl == tr) {
            return Data[vr].first;
        }
        if ((tl == l_) && (tr == r_)) {
            return Data[vr].first;
        }
        int Mid = (tl + tr) / 2;
        return Get(2 * vr, tl, Mid, l_, std::min(r_, Mid)) +
                Get(2 * vr + 1, Mid + 1, tr, std::max(l_, Mid + 1), r_);
    }
    void update(int vr, int tl, int tr, int l_, int r_, int var) {
        if ((l_>r_)||(tl > tr)) {
            return;
        }

        push(vr, tl, tr);
        if ((tl == tr) || ((tl == l_) && (tr == r_))) {
            Data[vr].first = sum(var, tr - tl + 1);
            Data[vr].second = var;
            push(vr, tl, tr);
            return;
        }
        int Mid = (tl + tr)/2;
        if (r_ <= Mid) {
            update(2 * vr, tl, Mid, l_, r_, var);
        } else if (l_ >= Mid + 1) {
            update(2 * vr + 1, Mid + 1, tr, l_, r_, var);
        } else {
            update(2 * vr, tl, Mid, l_, Mid, var);
            update(2 * vr + 1, Mid + 1, tr, Mid + 1, r_, var + Mid - l_ + 1);
        }
        Data[vr].first = Data[2*vr].first + Data[2*vr+1].first;
        return;
    }

    void DebugPrint() {
        for(unsigned int i=0; i<Data.size();++i) {
            std::cout << Data[i].first << ' ';
        }
        std::cout << '\n';
        for(unsigned int i=0; i<Data.size();++i) {
            std::cout << Data[i].second << ' ';
        }
        std::cout << "\n\n";
    }

};

int main() {
    std::fstream fi, fo;
    int op, l, r, n, m;
    fi.open("input.txt", std::fstream::in);
    fo.open("output.txt", std::fstream::out);
    fi >> n;
    std::vector<int> inp(n);
    for(int i = 0; i<n; ++i) {
        fi >> inp[i];
    }
    Tree Data(inp);
    //Data.DebugPrint();

    fi >> m;
    for(int i=0; i<m; ++i) {
        fi >> op >> l >> r;
        if (op == 1) {
            fo << Data.Get(1, 1, n, l, r) << '\n';
        } else {
            Data.update(1, 1, n, l, r, 1);
        }
    }

    //Data.DebugPrint();

    fi.close();
    fo.close();
}