#include <bits/stdc++.h>
#define ll long long
#define sti string
#define bit(n,i) ((n>>i) &1)
#define itachi ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define maxn 500500
#define fi first
#define se second
#define int long long


using namespace std;

vector<pair<int,int>> seg[4*maxn];
int val[maxn];
pair<int,int> edge[maxn];

struct node {
  int u,v,sz_u,numedge_u,Min_u,sum_u,ans;
};

int m;

struct DSU {
   vector<int> par,sz,numedge,Min,sum;
   vector<node> st;
   int ans=0;
   int n;
   int is_bipar;

   DSU(int _n=0){
      n=_n;
      par.assign(n+5,0);
      sz.assign(n+5,1);
      numedge.assign(n+5,0);
      Min.assign(n+5,0);
      sum.assign(n+5,0);


      for(int i=1;i<=n;i++) {
          par[i]=i;
          Min[i]=val[i];
          sum[i]=val[i];
      }
      ans=0;
   }

   int find_par(int u){
      while(u!=par[u]){
         u=par[u];
      }
      return u;
   }

   int get(int r) {
      if(numedge[r] < sz[r]) return sum[r] - Min[r];
      return sum[r];
   }

   void join(int u,int v){
      int ru =find_par(u);
      int rv =find_par(v);

      if(ru==rv){
         st.push_back({ru,-1,sz[ru],numedge[ru],Min[ru],sum[ru],ans});
         ans -= get(ru);
         numedge[ru]++;
         ans += get(ru);
         return;
      }

      if(sz[ru]<sz[rv]){
         swap(ru,rv);
      }

      st.push_back({ru,rv,sz[ru],numedge[ru],Min[ru],sum[ru],ans});
      ans -= get(ru);
      ans -= get(rv);
      par[rv]=ru;
      sz[ru]+=sz[rv];
      numedge[ru] += numedge[rv]+1;
      Min[ru] = min(Min[ru],Min[rv]);
      sum[ru] += sum[rv];

      ans += get(ru);
   }

   void rollback(int Time){
      while((int)st.size()>Time){
         auto [u,v,sz_u,numedge_u,Min_ru,Sum_ru,old_ans]=st.back();
         st.pop_back();

         ans = old_ans;

         if(v==-1) {
             numedge[u] = numedge_u;
         } else {
             par[v]=v;
             sz[u]=sz_u;
             numedge[u] = numedge_u;
             Min[u] = Min_ru;
             sum[u] = Sum_ru;
         }
      }
   }
};

void update(int id,int l,int r,int u,int v,pair<int,int> edge){
   if(l>r || u>v || l>v || r<u) return ;
   if(u<=l && r<=v){
      seg[id].push_back(edge);
      return ;
   }
   int m=(l+r)/2;
   update(id*2,l,m,u,v,edge);
   update(id*2+1,m+1,r,u,v,edge);
}

struct Query {
   int opt;
   int u, v;
};

DSU dsu ;
vector<int> ans;
Query que[maxn];
int n,k;

void dfs(int id, int l, int r) {
    int snap = dsu.st.size();
    for(auto [u,v] : seg[id]) dsu.join(u,v);
    if(l == r) {
        if(l>1) ans.push_back(dsu.ans);
    }
    else {
        int mid = (l + r) >> 1;
        dfs(id << 1, l, mid);
        dfs(id << 1 | 1, mid + 1, r);
    }
    dsu.rollback(snap);
}

map<pair<int,int>,int> start;

signed main()
{
    itachi
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++) cin>>val[i];
    for(int i=1;i<=m;i++){
        int u,v;
        cin>>u>>v;
        if(u>v) swap(u,v);
        edge[i]={u,v};
        start[{u,v}]=1;
    }
    dsu = DSU(n);
    int idans=1;
    for(int i = 2; i <= k+1; i++) {
        int c,id;
        cin>>c>>id;
        int u = edge[id].fi;
        int v = edge[id].se;
        if(u > v) swap(u, v);
        if(c == 2) {
            start[{u, v}] = i ;
        }
        else {
            int L = start[{u, v}];
            start.erase({u, v});

            update(1, 1, k+1 ,L, i-1 ,{u, v});
            start[{u,v}] = 0;
        }
    }

    for(auto &it : start) {
        auto [e, L] = it;
       if(start[e] > 0 ) update(1, 1, k+1 ,L, k+1,{e.fi, e.se});
    }

    dfs(1, 1, k+1 );
    for(int x : ans)
        cout << x << '\n';
    return 0;
}