#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

ifstream in("secv5.in");
ofstream out("secv5.out");

const int NMAX = (1<<20) + 1;
const int HASHKEY = 1666013;

unsigned int Hash[NMAX];
unsigned int HashKey[NMAX];

unsigned int V[NMAX], N, U, L;
vector<pair<int,int> > Values;

bool addToHash(unsigned int value){

    Hash[value]++;

    if(Hash[value] > 1){
        return false;
    }

    return true; //new element
}

bool eraseFromHash(unsigned int value){
    Hash[value]--;

    if(Hash[value] > 0){
        return false;
    }

    return true;//element does not exist in the hash from now
}

void clearHashTable(){
    for(int i = 0; i < NMAX; i++)
        Hash[i] = 0;
}

long long resolve(unsigned int maxCounter){
    unsigned int i, distinctElements = 0;

    long long sol=0;

    unsigned int left = 0, right = 0;

    clearHashTable();

    for(; right < N; right++){
        if(addToHash(HashKey[right])){
            distinctElements++;
        }

        while(distinctElements > maxCounter ){
            if(eraseFromHash(HashKey[left])){
                distinctElements--;
            }

            left++;
        }

        if(distinctElements <= maxCounter)
            sol += right - left + 1;
    }
    return sol;

}

inline bool comp(const pair<int,int> &a, const pair<int,int> b){
    return a.first < b.first;
}

int main()
{
    in >> N >> U >> L;

    for(int i = 0 ; i < N; i++){
        in >> V[i];

        Values.push_back(make_pair(V[i],i));
    }

    sort(Values.begin(),Values.end(), comp);
    int counter = 0;

    HashKey[Values[0].second] = 0;

    for(int i = 1; i < N; i++){
        if(Values[i].first != Values[i-1].first){
            HashKey[Values[i].second] = ++counter;
        }
        else
            HashKey[Values[i].second] = HashKey[Values[i-1].second];
    }

    long long Lsol = resolve(L);
    long long Usol = resolve(U-1);
    out << Lsol - Usol;
    return 0;
}