Codeforces Mishkaan & Interesting Sum

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;


public class Mishkaandinterestingsum implements Runnable{


    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");
    int seg[];
    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine(), " :");
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

 
    public static void main(String[] args) {
        new Thread(null, new Mishkaandinterestingsum(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

 

   

    void solve() throws IOException {
        int n = readInt();
        int a[]=new int[n];
        seg=new int[4*n];
        int i,j=0;
        int dp[]=new int[n];
        for(i=0;i<n;i++)
        {
        a[i]=readInt();
        if(i!=0)
        dp[i]=dp[i-1]^a[i];
        else
        dp[i]=a[i];
        }
       
        int m=readInt();
        int ans[]=new int[m];
        Query q[]=new Query[m];
       
        for(i=0;i<m;i++)
        {
        int l=readInt()-1;
        int r=readInt()-1;
        q[i]=new Query(l,r,i);
        }
       
        Arrays.sort(q);
       // for(int t=0;t<q.length;t++)
       // {
        //System.out.println("l="+q[t].l+" r="+q[t].r);
       // }
        Map<Integer,Integer> h=new HashMap<Integer,Integer>();
        for(i=0;i<n;i++)
        {
        if(h.containsKey(a[i]))
        {
        int index=h.get(a[i]);
        //out.println("value "+a[i]+"at index="+index);
        update(0,n-1,index,0,0);
        }
        h.put(a[i],i);
       
    //out.println("value "+a[i]+"at index="+index);
        update(0,n-1,i,0,a[i]);
       
        for(;j<m &&q[j].r==i;j++)
        {
        int k=find(0,n-1,q[j].l,q[j].r,0);
        k^=dp[q[j].r];
        if(q[j].l!=0)
        k^=dp[q[j].l-1];
       
        ans[q[j].i]=k;
       
        //out.println("Seqment tree");
               // for(int t=0;t<seg.length;t++)
               // {
                //out.print(seg[t]+" ");
                //}
        }
        }
        for(i=0;i<m;i++)
        {
        out.println(ans[i]);
        }
        out.close();
     
       

    }
    public void update(int a,int b,int loc,int root,int v)
    {
   
    if(a==b){
    seg[root]=v;
    return;
    }
   
    int mid=(a+b)>>1;
        if(loc<=mid)
    update(a,mid,loc,2*root+1,v);
        else
    update(mid+1,b,loc,2*root+2,v);
   
    seg[root]=seg[2*root+1]^seg[2*root+2];
   
    }
    public int find(int a,int b,int s,int e,int root)
    {
   
    if(s<=a && b<=e)
    return seg[root];
   
   
    int mid=(a+b)>>1;
    if(mid>=e)
    return find(a,mid,s,e,2*root+1);
    if(mid<s)
        return find(mid+1,b,s,e,2*root+2);
   
    return find(a,mid,s,e,2*root+1)^find(mid+1,b,s,e,2*root+2);
   
   
    }
    class Query implements Comparable<Query>
    {
    int l;
    int r;
    int i;
   
    Query(int l,int r,int i)
    {
    this.l=l;
    this.r=r;
    this.i=i;
    }
   
   
    public int compareTo(Query o)
    {
    if(this.r!=o.r)
    return this.r-o.r;
    else
    return this.l-o.l;
   
    }
   
    }

}