#include <fstream>
#include <algorithm>

typedef long long LL;

using namespace std;

const int Nmax = 100005;

struct q{
    int start, finish, indice;
    LL sol;
};

int n, k, m;
LL aib[Nmax];
int v[Nmax], ultima_aparitie[Nmax];
q querys[Nmax];

int lsb(int x){
    return (x & (-x));
}

void update(int poz, int val){
    for(int i = poz; i <= n; i += lsb(i)){
        aib[i] += val;
    }
}

LL query(int poz){
    LL sol = 0;

    for(int i = poz; i > 0; i -= lsb(i)){
        sol += aib[i];
    }

    return sol;
}

LL query(int lft, int rgt){
    return query(rgt) - query(lft - 1);
}

bool cmp1(q a, q b){
    if(a.finish == b.finish){
        return a.start < b.start;
    }
    return a.finish < b.finish;
}

bool cmp2(q a, q b){
    return a.indice < b.indice;
}

int main(){
    ifstream fin("distincte.in");
    ofstream fout("distincte.out");

    int capat_dr;

    fin >> n >> k >> m;

    for(int i = 1; i <= n; i++){
        fin >> v[i];
    }
    for(int i = 1; i <= m; i++){
        fin >> querys[i].start >> querys[i].finish;
        querys[i].indice = i;
    }

    sort(querys + 1, querys + m + 1, cmp1);

    capat_dr = 0;
    for(int p = 1; p <= m; p++){
        while(capat_dr < querys[p].finish){
            capat_dr++;

            if(ultima_aparitie[v[capat_dr]]){
                update(ultima_aparitie[v[capat_dr]], -v[capat_dr]);
            }

            ultima_aparitie[v[capat_dr]] = capat_dr;
            update(capat_dr, v[capat_dr]);
        }

        querys[p].sol = query(querys[p].start, querys[p].finish);
    }

    sort(querys + 1, querys + m + 1, cmp2);

    for(int i = 1; i <= m; i++){
        fout << querys[i].sol << '\n';
    }

    return 0;
}