/**
     *    author:   K.R.Surrya  
     *    created:  21.06.2020 17:35:21
    **/
    //~ ~~ ~~~~ ~~~~~~~~   
    #include<bits/stdc++.h>
    using namespace std; 
    using lint  =                           long long int;
    using pint  =                           pair<int, int>;
    using plint =                           pair<lint, lint>;
    #define arr                             array
    #define vi                              vector<int>
    #define vli                             vector<lint>
    #define pb                              push_back
    #define ALL(x)                          begin(x),end(x)
    #define inf                             (1LL<63)-1
    #define MOD                             1000000007
    #define SZ(x)                           ((lint)(x).size())
    #define                                 FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
    #define                                 IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
    #define                                 REP(i, n) FOR(i,0,n)
    #define                                 IREP(i, n) IFOR(i,0,n)
    #define                                 f_ip   ios_base::sync_with_stdio(false); cin.tie(NULL);
    #define ZERO(a)                         fill(ALL(a),0)
    #define lastBit(n)                      31-__builtin_clz(n) + 1 //32 bit integers, 1-based indexing.
    #define firstBit(n)                     __builtin_ctz((n&(-n))) + 1
    struct fast_ios                         { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
    template<typename T>                    istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
    template<typename T>                    bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
    template<typename T>                    bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
    mt19937                                 rng(chrono::steady_clock::now().time_since_epoch().count());



            /* ~Debugging~ */         
        /*~~~~~~~~~~~~~~~~~*/       
    #define LOCAL
    #define sim template <class c
    #define ris return *this
    #define dor > deb &operator<<
    #define eni(x)                                                                  \
        sim > typename enable_if<sizeof dud<c>(0) x 1, deb &>::type operator<<(c i) \
        {
    sim > struct rge
    {
        c b, e;
    };
    sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
    sim > auto dud(c *x) -> decltype(cerr << *x, 0);
    sim > char dud(...);
    struct deb
    {
    #ifdef LOCAL
        ~deb()
        {
            cerr << endl;
        }
        eni(!=) cerr << boolalpha << i;
        ris;
    } eni(==) ris << range(begin(i), end(i));
    }
    sim, class b dor(pair<b, c> d)
    {
        ris << "(" << d.first << ", " << d.second << ")";
    }
    sim dor(rge<c> d)
    {
        *this << "[";
        for (auto it = d.b; it != d.e; ++it)
            *this << ", " + 2 * (it == d.b) << *it;
        ris << "]";
    }
    #else
        sim dor(const c &)
        {
            ris;
        }
    #endif
    }
    ;
    #define what(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
    // -DLOCAL



        /*  ~magic~ */            
        /*~~~~~~~~~~~~~~~*/           
    #define magic(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
    void err(istream_iterator<string> it)  { return ;}
    template<typename T, typename... Args>
    void err(istream_iterator<string> it, T a,Args... args)
    {
    cerr << *it << " = " << a <<endl;
    err(++it,args...);   //args is going to end.
    }



        /* ~driver~ */
        /*~~~~~~~~~~*/
    void solve() {
        lint n;
        cin >> n;
        vector<lint> a(n);
        cin >> a;
        int q;cin >> q;

        lint ret=accumulate(ALL(a),0LL);

        map<lint,lint> f;

        REP(i,n) {
            lint curr=a[i];
            ++f[a[i]];
        }

        REP(i,q) { 

            lint b,c;cin >> b >> c;

            lint rem=f[b];

            ret-= rem*b;
            ret+= rem*c;

            f[c]+=f[b];
            f[b]=0;

            cout << ret << '\n';
        }
    }


    int main()
    {   
        #if 0
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
        #endif

        int T=1;
        //cin>>T;
        for(int tt=1;tt<=T;++tt) {
            solve();
        }

        return 0;
    }


        /* ~Modulus functions~ */
        /*~~~~~~~~~~~~~~~~~~~~~~~*/
    lint pow_mod(lint base,lint expo) { 
    lint ret = 1;
    for(;expo;) { 
        if(expo&1)  ret = (ret*base)%MOD; 

        expo = (expo>>1);
        base = (base*base)%MOD;
    }
    return ret;
    }


Measured memory_bytes: 10076