func_code_string: #include <bits/stdc++.h>   using namespace std;   class IO {     static const int bufSize = 1 << 18;     char inBuf[bufSize], outBuf[bufSize];     char *ip1 = inBuf, *ip2 = inBuf;     int goodReadBit = 0, op1 = -1, op2 = bufSize - 1;     template <typename T>     __inline__ __attribute__((always_inline)) void __RI(T& x) {       int ch = gc(), neg = 1;       x = 0;       for (; !(isdigit(ch) || ch ==  -  || ch == EOF); ch = gc())         ;       if (ch == EOF) {         goodReadBit = 0;         return;       }       if (ch ==  - ) neg = -1, ch = gc();       for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;     }     template <typename T>     __inline__ __attribute__((always_inline)) void __RC(T& x) {       unsigned char ch;       while (isspace(ch = gc()))         ;       x = ch;     }     __inline__ __attribute__((always_inline)) void __RS(string& x) {       char ch;       x.clear();       for (ch = gc(); isspace(ch); ch = gc())         ;       if (ch == EOF) {         goodReadBit = 0;         return;       }       for (; !isspace(ch); ch = gc()) x.push_back(ch);     }       public:     __inline__ __attribute__((always_inline)) int gc() {       return ip1 == ip2 && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),                             ip1 == ip2)                  ? EOF                  : *ip1++;     }     __inline__ __attribute__((always_inline)) IO& R(char& x) {       __RC(x);       return (*this);     }     __inline__ __attribute__((always_inline)) IO& R(unsigned char& x) {       __RC(x);       return (*this);     }     __inline__ __attribute__((always_inline)) IO& R(string& x) {       __RS(x);       return (*this);     }     template <typename T1, typename T2>     __inline__ __attribute__((always_inline)) IO& R(pair<T1, T2>& x) {       R(x.first), R(x.second);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& R(vector<T>& x) {       for (auto& i : x) R(i);       return (*this);     }     template <typename T, typename... Args>     __inline__ __attribute__((always_inline)) IO& RA(T* a, int n) {       for (int i = 0; i < n; ++i) R(a[i]);       return (*this);     }     template <typename T, typename... Args>     __inline__ __attribute__((always_inline)) IO& R(T& x, Args&... args) {       R(x), R(args...);       return (*this);     }     template <typename T, typename... Args>     __inline__ __attribute__((always_inline)) IO& RA(T* a, int n, Args... args) {       for (int i = 0; i < n; ++i) RA(a[i], args...);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& R(T& x) {       static_assert(is_integral<T>::value,  Unsupported types );       if (is_integral<T>::value) __RI(x);       return (*this);     }       private:     char space =    ;     template <typename T>     __inline__ __attribute__((always_inline)) void __WI(T x) {       static char buf[64];       static int len = -1;       if (x >= 0) {         do {           buf[++len] = x % 10 + 48, x /= 10;         } while (x);       } else {         pc( - );         do {           buf[++len] = -(x % 10) + 48, x /= 10;         } while (x);       }       while (len >= 0) {         pc(buf[len]), --len;       }     }       public:     __inline__ __attribute__((always_inline)) void pc(const char& x) {       if (op1 == op2) flush();       outBuf[++op1] = x;     }     __inline__ __attribute__((always_inline)) void flush() {       fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1;     }     __inline__ __attribute__((always_inline)) IO& W(const char& x) {       pc(x);       return (*this);     }     __inline__ __attribute__((always_inline)) IO& W(const char* x) {       while (*x !=   0 ) pc(*(x++));       return (*this);     }     __inline__ __attribute__((always_inline)) IO& W(const string& x) {       W(x.c_str());       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& W(const vector<T>& x) {       for (auto& i : x) WS(i);       WL();       return (*this);     }     __inline__ __attribute__((always_inline)) IO& WL() {       W(  n );       return (*this);     }     template <typename T1, typename T2>     __inline__ __attribute__((always_inline)) IO& W(const pair<T1, T2>& x) {       WS(x.first), W(x.second);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& WL(const T& x) {       W(x), W(  n );       return (*this);     }     __inline__ __attribute__((always_inline)) IO& WS() {       W(   );       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& WS(const T& x) {       W(x), W(space);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& WA(T* a, int n) {       for (int i = 0; i < n; i++) WS(a[i]);       WL();       return (*this);     }     template <typename T, typename... Args>     __inline__ __attribute__((always_inline)) IO& W(const T& x,                                                     const Args&... args) {       W(x), W(space), W(args...);       return (*this);     }     template <typename... Args>     __inline__ __attribute__((always_inline)) IO& WL(const Args&... args) {       W(args...), W(  n );       return (*this);     }     template <typename T, typename... Args>     __inline__ __attribute__((always_inline)) IO& WA(T* a, int n, Args... args) {       for (int i = 0; i < n; i++) WA(a[i], args...);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& W(const T& x) {       static_assert(is_integral<T>::value,  Unsupported types );       if (is_integral<T>::value) __WI(x);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& operator>>(T& x) {       R(x);       return (*this);     }     template <typename T>     __inline__ __attribute__((always_inline)) IO& operator<<(const T& x) {       W(x);       return (*this);     }     IO() {}   } io;   void EXIT(int code) { io.flush(), exit(code); }   const int8_t INFC = 0x3f;   const int16_t INFS = 0x3f3f;   const int32_t INF = 0x3f3f3f3f;   const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;   const int BLOCK_SIZE = 512;   struct Block {     int n;     vector<int> cnt, to, lst, &a;     Block(int n, vector<int>& a) : n(n), a(a) {       cnt.assign(n, -1), to.assign(n, -1), lst.assign(n, -1);     }     inline void __upd(int i, int j, int n) {       if (a[j] + i >= n) {         to[i] = a[j] + i - n;         lst[i] = j;         cnt[i] = 1;       } else {         to[i] = to[a[j] + i];         lst[i] = lst[a[j] + i];         cnt[i] = cnt[a[j] + i] + 1;       }     }     void update(int pos) {       if (n == BLOCK_SIZE) {         for (int i = n - 1; i >= 0; i -= 4) {           __upd(i, i + pos, n);           __upd(i - 1, i + pos - 1, n);           __upd(i - 2, i + pos - 2, n);           __upd(i - 3, i + pos - 3, n);         }       } else {         for (int i = n - 1; i >= 0; i--) {           int j = i + pos;           if (a[j] + i >= n) {             to[i] = a[j] + i - n;             lst[i] = j;             cnt[i] = 1;           } else {             to[i] = to[a[j] + i];             lst[i] = lst[a[j] + i];             cnt[i] = cnt[a[j] + i] + 1;           }         }       }     }   };   vector<Block> blocks;   int main() {     int n, q;     io >> n >> q;     vector<int> v(n);     io >> v;     for (int i = 0; i < n; i += BLOCK_SIZE) {       blocks.push_back(Block(min(BLOCK_SIZE, n - i), v));       blocks.back().update(i);     }     while (q--) {       int op, a;       io >> op >> a;       --a;       if (op == 1) {         int bpos = a / BLOCK_SIZE;         a = a % BLOCK_SIZE;         int cnt = 0, ans = 0;         while (bpos < blocks.size()) {           if (a >= blocks[bpos].n) break;           cnt += blocks[bpos].cnt[a];           ans = blocks[bpos].lst[a];           a = blocks[bpos].to[a];           bpos += a / BLOCK_SIZE;           a %= BLOCK_SIZE;           bpos++;         }         io.WL(ans + 1, cnt);       } else {         int b;         io >> b;         v[a] = b;         blocks[a / BLOCK_SIZE].update(a / BLOCK_SIZE * BLOCK_SIZE);       }     }     EXIT(0);   }   