#include <fstream>
#include <iostream>
#include <map>
#include <hash_map>
#include <iterator>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cstdlib>
       
#define MAXN ((1<<20) + 1)
#define HASH_SIZE 19793
       
using namespace std;
       
unsigned int vec[MAXN];
//unsigned int minimumSpans[MAXN];
      
typedef unsigned int uint32;
  
struct Bucket
{
    uint32 Key;
    uint32 Count;
};
  
typedef vector<Bucket> HashBucket;

template <const int HashSize>
class HashTable
{
public:
    uint32& operator [] (uint32 key)
    {
        uint32 hash = key % HashSize;
         
        for (int i=0; i<table[hash].size(); ++i)
        {
            if (table[hash][i].Key == key)
            {
                return table[hash][i].Count;
            }
        }

        Bucket b = {key, 0};
        table[hash].emplace_back(b);

        return table[hash][table[hash].size() - 1].Count;
    }

    void erase(uint32 key)
    {
        uint32 hash = key % HashSize;
         
        for (int i=0; i<table[hash].size(); ++i)
        {
            if (table[hash][i].Key == key)
            {
                table[hash].erase(table[hash].begin() + i);
                return;
            }
        }
    }
         
    void clear()
    {     
        for (int i=0; i<HashSize; ++i)
        {
            table[i].clear();
        }
    }
           
private:
       
    HashBucket table[HashSize];
};
      
HashTable<HASH_SIZE> mapDistincts;
       
int main()
{
    int n, L, U;
    long long numSecv = 0;
    fstream fin("secv5.in" , fstream::in);
    fstream fout("secv5.out", fstream::out);
        
    fin.seekg(0, ios::end);
    int end = fin.tellg();
        
    char* buffer = static_cast<char*>(malloc(end));
    
    fin.seekg (0, ios::beg);
    fin >> n >> L >> U;
    //cout << n << " " << L << " " << U << endl;
        
    //fin.read(buffer, end);
    //cout << buffer << endl;
    
    char* pCurrent = buffer;
    for (int i=1; i<=n; ++i)
    {
        fin >> vec[i];
        pCurrent++;
        while (*pCurrent >= '0' && *pCurrent <= '9')
        {
            vec[i] = 10*vec[i] + (*pCurrent - 48);
            pCurrent++;
        }
          
        //cout << vec[i] << " ";
    }
    //cout << endl;
        
    //free(buffer);
    unsigned int distincts = 0;
    int span = 1;
    long long numSeqsL = 0;
    long long numSeqsU = 0;
           
    for (int i=1; i<=n; ++i)
    {
        mapDistincts[vec[i]]++;
        if (mapDistincts[vec[i]] == 1)
        {
            distincts++;
             
            while (distincts > L-1)
            {
                mapDistincts[vec[span]]--;
                if (mapDistincts[vec[span]] == 0)
                {
                    mapDistincts.erase(vec[span]);
                    distincts--;
                }

                span++;
            }
        }

        numSeqsL += (i - span + 1);
   
        //minimumSpans[i] = span;
    }

    mapDistincts.clear();

    distincts = 0;
    span = 1;

    for (int i=1; i<=n; ++i)
    {
        mapDistincts[vec[i]]++;
        if (mapDistincts[vec[i]] == 1)
        {
            distincts++;
             
            while (distincts > U)
            {
                mapDistincts[vec[span]]--;
                if (mapDistincts[vec[span]] == 0)
                {
                    mapDistincts.erase(vec[span]);
                    distincts--;
                }
                       
                span++;
            }
        }
        
        numSeqsU += (i - span + 1);

        //numSecv += (minimumSpans[i] - span);
    }
    
    //cout << numSeqsU << " " << numSeqsL << endl;

    //mapDistincts.clear();
    
    fout << numSeqsU - numSeqsL << "\n";
           
    //fout << numSecv << "\n";
           
    return 0;
}