#include<set>

 #include<cmath>

 #include<queue>

 #include<vector>

 #include<cstdio>

 #include<cstring>

 #include<iostream>

 #include<algorithm>

 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)

 using namespace std;

 typedef long long ll;

 const int N = 3e5+;

 ll read() {

     char c=getchar();

     ll f=,x=;

     while(!isdigit(c)) {

         if(c=='-') f=-; c=getchar();

     }

     while(isdigit(c))

         x=x*+c-'',c=getchar();

     return x*f;

 }

 struct UFS {

     int p[N];

     int ifind(int x) {

         if(p[x]==||x==p[x]) return p[x]=x;

         return p[x]=ifind(p[x]);

     }

     void iunion(int x,int y) {

         x=ifind(x),y=ifind(y);

         if(x!=y) p[x]=y;

     }

 } bcc,S;

 namespace LCT {

     struct Node {

         Node *ch[],*fa;

         int v,rev,sum;

         Node() {}

         Node(int x) ;

         void reverse() {

             rev^=;

             swap(ch[],ch[]);

         }

         void up_push() {

             if(fa->ch[]==this||fa->ch[]==this)

                 fa->up_push();

             if(rev) {

                 ch[]->reverse();

                 ch[]->reverse();

                 rev=;

             }

         }

         void maintain() {

             sum=v+ch[]->sum+ch[]->sum;

         }

     } T[N],*null=&T[];

     Node::Node(int x) {

         rev=;

         v=sum=x;

         ch[]=ch[]=fa=null;

     }

     void rot(Node* o,int d) {

         Node *p=o->fa;

         p->ch[d]=o->ch[d^];

         o->ch[d^]->fa=p;

         o->ch[d^]=p;

         o->fa=p->fa;

         if(p==p->fa->ch[])

             p->fa->ch[]=o;

         else if(p==p->fa->ch[])

             p->fa->ch[]=o;

         p->fa=o;

         p->maintain();

     }

     void splay(Node *o) {

         o->up_push();

         Node *nf,*nff;

         while(o->fa->ch[]==o||o->fa->ch[]==o) {

             nf=o->fa,nff=nf->fa;

             if(o==nf->ch[]) {

                 if(nf==nff->ch[]) rot(nf,);

                 rot(o,);

             } else {

                 if(nf==nff->ch[]) rot(nf,);

                 rot(o,);

             }

         }

         o->maintain();

     }

     void Access(Node *o) {

         Node *son=null;

         while(o!=null) {

             splay(o);

             o->ch[]=son;

             o->maintain();

             o->fa=&T[bcc.ifind(o->fa-T)];

             son=o; o=o->fa;

         }

     }

     void evert(Node *o) {

         Access(o);

         splay(o);

         o->reverse();

     }

     void Link(Node *u, Node *v) {

         evert(u);

         u->fa=v;

     }

 }

 using namespace LCT;

 int n,m,a[N];

 void merge(Node* &u,Node* v)

 {

     if(u==null) return ;

     v->v+=u->v;

     bcc.iunion(u-T,v-T);

     merge(u->ch[],v);

     merge(u->ch[],v);

     u=null;

 }

 int main()

 {

     n=read(),m=read();

     FOR(i,,n) {

         a[i]=read(); T[i]=Node(a[i]);

     }

     int op,u,v;

     FOR(i,,m) {

         op=read(),u=read(),v=read();

         if(op==) {

             u=bcc.ifind(u),v=bcc.ifind(v);

             if(u==v) continue;

             if(S.ifind(u)!=S.ifind(v))

                 Link(&T[u],&T[v]),

                 S.iunion(u,v);

             else {

                 evert(&T[u]);

                 Access(&T[v]),splay(&T[v]);

                 merge(T[v].ch[],&T[v]);

                 merge(T[v].ch[],&T[v]);

                 T[v].maintain();

             }

         } else

         if(op==) {

             splay(&T[bcc.ifind(u)]);

             T[bcc.ifind(u)].v+=v-a[u];

             T[bcc.ifind(u)].maintain();

             a[u]=v;

         } else {

             u=bcc.ifind(u),v=bcc.ifind(v);

             if(S.ifind(u)!=S.ifind(v)) puts("-1");

             else {

                 evert(&T[u]);

                 Access(&T[v]),splay(&T[v]);

                 printf("%d\n",T[v].sum);

             }

         }

     }

     return ;

 }