#include<fstream>
#include<algorithm>
using namespace std ;

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

#define maxn 100001

struct qq
{
    int s, e, ind ;
};

int N, K, M ;

int v[maxn] ;

qq q[maxn] ;

int sol[maxn] ;

int urm[maxn], in[maxn] ;
int poz[maxn] ;

int aint[2 * maxn] ;

bool cmp(qq A, qq B)
{
    if( A.e < B.e )
        return false ;

    if( A.e > B.e )
        return true ;

    if( A.e == B.e && A.s > B.s )
        return true ;

    return false ;
}

int query(int nod, int st, int dr, int qs, int qd)
{
    if( st == dr )
        return aint[nod] ;

    int fiust = 2 * nod ;
    int fiudr = 2 * nod + 1 ;
    int mij = ( ( st + dr ) >> 1 ) ;

    if( qs >= st && qd <= mij )
        return query( fiust, st, mij, qs, qd ) ;

    if( qs > mij && qd <= dr )
        return query( fiudr, mij + 1, dr, qs, qd ) ;

    return query( fiust, st, mij, qs, mij ) + query( fiudr, mij + 1, dr, mij + 1, qd ) ;
}

void update(int nod, int st, int dr, int p)
{
    if( st == dr )
    {
        aint[nod] = v[p] ;
        return ;
    }

    int fiust = 2 * nod ;
    int fiudr = 2 * nod + 1 ;
    int mij = ( ( st + dr ) >> 1 ) ;

    if( p <= mij )
        update( fiust, st, mij, p ) ;
    else
        update( fiudr, mij + 1, dr, p ) ;

    aint[nod] = aint[fiust] + aint[fiudr] ;
}

int main()
{
    fin >> N >> K >> M ;

    for(int i = 1; i <= N; ++i )
        urm[i] = N + 2 ;

    for(int i = 1; i <= N; ++i )
    {
        fin >> v[i] ;

        if( poz[ v[i] ] )
            urm[ poz[ v[i] ] ] = i, in[i] = poz[ v[i] ] ;

        poz[ v[i] ] = i ;
    }

    for(int i = 1; i <= M; ++i )
    {
        fin >> q[i].s >> q[i].e ;
        q[i].ind = i ;
    }

    sort( q + 1, q + M + 1, cmp ) ;

    for(int i = 1; i <= N; ++i )
        if( urm[i] > q[1].e )
            update( 1, 1, N, i ) ;

    sol[ q[1].ind ] = query( 1, 1, N, q[1].s, q[1].e ) ;
/*
    for(int i = 2; i <= M; ++i )
    {
        if( q[i].e == q[i - 1].e )
            sol[ q[i].ind ] = query( 1, 1, N, q[i].s, q[i].e ) ;
        else
        {
            for(int j = q[i - 1].e; j > q[i].e; --j )
                if( in[j] > 0 )
                    update( 1, 1, N, in[j] ) ;

            sol[ q[i].ind ] = query( 1, 1, N, q[i].s, q[i].e ) ;
        }
    }

    for(int i = 1; i <= M; ++i )
        fout << sol[i] << "\n" ;
*/
    return 0 ;
}