#include<bits/stdc++.h>

using namespace std;

const int MAXN = 2e5 + ;

typedef long long ll;

typedef long double ld;

typedef unsigned long long ull;

int n;

int k[MAXN];

struct Link_Cut_Tree

{

        struct Node

        {

                int father , son[] , size;

                bool tag;

        } a[MAXN];

        inline void init()

        {

                for (int i = ; i <= n; i++)

                {

                        a[i].father = ;

                        a[i].son[] = a[i].son[] = ;

                        a[i].size = ;

                        a[i].tag = false;

                }

        }

        inline void pushdown(int x)

        {

                if (a[x].tag)

                {

                        swap(a[x].son[] , a[x].son[]);

                        a[a[x].son[]].tag ^= ;

                        a[a[x].son[]].tag ^= ;

                        a[x].tag = false;

                }

        }

        inline void update(int x)

        {

                a[x].size = ;

                if (a[x].son[]) a[x].size += a[a[x].son[]].size;

                if (a[x].son[]) a[x].size += a[a[x].son[]].size;

        }

        inline bool get(int x)

        {

                pushdown(a[x].father);

                return a[a[x].father].son[] == x;

        }

        inline bool nroot(int x)

        {

                return a[a[x].father].son[] == x | a[a[x].father].son[] == x;

        }

        inline void rotate(int x)

    {

        int f = a[x].father , g = a[f].father;

        int tmpx = get(x) , tmpf = get(f);

        int w = a[x].son[tmpx ^ ];

        if (nroot(f)) a[g].son[tmpf] = x;

        a[x].son[tmpx ^ ] = f;

        a[f].son[tmpx] = w;

        if (w) a[w].father = f;

        a[f].father = x;

        a[x].father = g;

        update(f);

    }

        inline void access(int x)

        {

                for (int y = ; x; x = a[y = x].father)

                {

                        splay(x);

                        a[x].son[] = y;

                        update(x);

                }

        }

        inline void splay(int x)

    {

        int y = x , z = ;

        static int st[MAXN];

        st[++z] = y;

        while (nroot(y)) st[++z] = y = a[y].father;

        while (z) pushdown(st[z--]);

        while (nroot(x))

        {

            int y = a[x].father , z = a[y].father;

            if (nroot(y))

                rotate((a[y].son[] == x) ^ (a[z].son[] == y) ? x : y);

            rotate(x);

        }

        update(x);

    }

        inline void make_root(int x)

        {

                access(x);

                splay(x);

                a[x].tag ^= ;

                pushdown(x);

        }

        inline int find_root(int x)

        {

                access(x);

                splay(x);

                while (a[x].son[])

                {

                        pushdown(x);

                        x = a[x].son[];

                }

                return x;

        }

        inline void link(int x , int y)

        {

                make_root(x);

                if (find_root(y) != x) a[x].father = y;

        }

        inline void cut(int x , int y)

        {

                make_root(x);

                if (find_root(y) == x && a[x].father == y && !a[x].son[])

                {

                        a[x].father = a[y].son[] = ;

                        update(y);

                 }

        }

        inline int query(int u)

        {

                make_root(u);

                access(n + );

                splay(n + );

                return a[n + ].size - ;

        }

        inline void modify(int u , int val)

        {

                if (u + k[u] <= n) cut(u , u + k[u]);

                else cut(u , n + );

                if (u + val <= n) link(u , u + val);

                else link(u , n + );

                k[u] = val;

        }

} LCT;

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }

template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }

template <typename T> inline void read(T &x)

{

    T f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

int main()

{

        read(n);

        LCT.init();

        for (int i = ; i <= n; i++)

        {

                read(k[i]);

                if (i + k[i] <= n) LCT.link(i , i + k[i]);

                else LCT.link(i , n + );

        }

        int m;

        read(m);

        while (m--)

        {

                int type;

                read(type);

                if (type == )

                {

                        int x;

                        read(x);

                        ++x;

                        printf("%d\n" , LCT.query(x));

                }    else

                {

                        int x , val;

                        read(x); read(val);

                        ++x;

                        LCT.modify(x , val);

                }

        }

        return ;

}