#include<bits/stdc++.h>


//      DEEP


using namespace std;
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define fwd(i,a,n) for(int i=a;i<=n;i++)
#define bak(i,a,n) for(int i=a;i>=n;i--)
#define all(v) v.begin(),v.end()
#define pb push_back
#define lop '\n'
#define mp make_pair

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<int,int> pi;
typedef set<int> si;
const ll mod = 1e9 + 7;
const ll mod1=998244353;
                                                    //power
ull power(ull x,ull y){
   if(y==0) return 1;
   else{
     if(y%2==0) return power(x*x,y/2);
     else return x*power(x*x,(y-1)/2);
   }
}

                        //                    Modular Exponentiation

ll mod_power(ll x, ll y, ll m)
{
    ll r = 1;     // Initialize result

    x = x % m; // Update x if it is more than or equal to m

    if (x == 0) return 0; // In case x is divisible by m;

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            r = (r*x) % m;

        // y must be even now
        y = y/2;
        x = (x*x) % m;
    }
    return r;
}

                                                      //GCD
ull gcd(ull x,ull y){
   if(y==0)return x;
   return gcd(y,x%y);
}
//                                         EXTENDED_EUCLID
vector<ll>extended_Euclid(ll a,ll b){
    vector<ll>v(3);
    if(b==0){
        v[0]=a;v[1]=1;v[2]=0;
        return v;
    }
    else{
         vector<ll>v1 = extended_Euclid(b,a%b);    //recursive call
         v[0]=v1[0];
         v[1]=v1[2];
         v[2]=v1[1]-(a/b)*v1[2];
         return v;
    }
}
                                          // DFS ( number of connected components  )
//vector<vector<ll> >adj(200001);
//bool visited[200001];
/*ll dfs(int x,int c){                         // x - > node      c - > number of edges in the component
    if(visited[x])return c;
    else{
        visited[x]=true;
        int y=c;
        for(int i=0;i<adj[x].size();i++){
            if(!visited[adj[x][i]]){
                c+=1;
                int d=dfs(adj[x][i],y);
                c+=d;
            }
        }
        return c;
    }
}
*/
                                              // SIEVE

/*
bool isPrime[100001];
void sieve(int N) {

        for(int i = 0; i <= N;++i) {
            isPrime[i]=true;
        }
        isPrime[0]=false;
        isPrime[1]=false;

        for(int i = 2; i * i <= N; ++i) {
             if(isPrime[i] == true) {
                 for(int j = i * i; j <= N ;j += i)
                     isPrime[j] = false;
            }
        }
    }
*/
                               // Binary Search
/*
ll bin_search(ll y){
  while(lo<hi){
    x=lo+(hi-lo)/2;
    if(condition){
            .....
    }
    else{
                  // increase lo or decrease hi suitably
            }
   }
}
*/
int b,c;
int n;
vll v(100000+1);
void segtree(int node,int start,int last){
    if(start==last){
        if(v[start]%2==0)BIT[node]=1;
        else BIT[node]=0;
    }
    else{
        int mid=(start+last)/2;
        segtree(2*node,start,mid);
        segtree(2*node+1,mid+1,last);
        BIT[node]=BIT[2*node]+BIT[2*node+1];
    }
}
ll min_query(int node,int start,int last,int l,int r){
    if(r<start or last<l){
        return mod;
    }
    else if(l<=start && last<=r)return BIT[node];
    int mid=(start+last)/2;
    int m1=min_query(2*node,start,mid,l,r);
    int m2=min_query(2*node+1,mid+1,last,l,r);
    return min(m1,m2);
}
ll sum(int node,int start,int last,int l,int r){
   if(r<start || last<l) return 0;
   else if(l<=start && last<=r)return BIT[node];
   int mid=(start+last)/2;
   ll s1=sum(2*node,start,mid,l,r);
   ll s2=sum(2*node+1,mid+1,last,l,r);
   return (s1+s2);
}
void update_segtree(int node,int start,int last,int idx,int val){
   if(start==last){

   }
   else{
      int mid=(start+last)/2;
      if(start<=idx && idx<=mid){
        update_segtree(2*node,start,mid,idx,val);
      }
      else{
        update_segtree(2*node+1,mid+1,last,idx,val);
      }
      BIT[node]=(BIT[2*node]+BIT[2*node+1]);
   }
}
ll xor_query(int node,int start,int last,int l,int r){
    if(r<start or l>last)return 0;
    else if(start<=l and r<=last){
        return BIT[node];
    }
    int mid=(start+last)/2;
    int p1=xor_query(2*node,start,mid,l,r);
    int p2=xor_query(2*node+1,mid+1,last,l,r);
    return (p1^p2);
}
ll even_query(int node,int start,int last,int l,int r){
    if(r<start or l>last)return 0;
    else if(l<=start and last<=r)return BIT[node];
    int mid=(start+last)/2;
    int a1=even_query(2*node,start,mid,l,r);
    int a2=even_query(2*node+1,mid+1,last,l,r);
    return (a1+a2);
}
void updateRangeUtil(int si, int ss, int se, int us,
                     int ue, int diff)
{
    if (ss>se || ss>ue || se<us)
        return ;

    // Current node is a leaf node
    if (ss==se)
    {

        if(BIT[si]==b)BIT[si]=c;
        return;
    }

    // If not a leaf node, recur for children.
    int mid = (ss+se)/2;
    updateRangeUtil(si*2+1, ss, mid, us, ue, diff);
    updateRangeUtil(si*2+2, mid+1, se, us, ue, diff);

    // Use the result of children calls to update this
    // node
    BIT[si] = BIT[si*2] + BIT[si*2+1];
}
int main(){
    boost;
    int TESTS=1;
    cin>>n;
    ll ans=0;
    map<int,int>M;
    for(int i=1;i<=n;i++){
            cin>>v[i];
            M[v[i]]+=1;
            ans+=v[i];
    }
    cin>>TESTS;
    while(TESTS--){

       cin>>b>>c;
       int x=M[b];
       ans-=M[b]*b;
       ans+=x*c;
       M[c]+=x;;
       M.erase(b);
       cout<<ans<<endl;

    }
}
/* Be careful about integer ranges;
   Check the corner cases before submitting.
*/




