#include <fstream>

using namespace std;

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


const int N = (1<<20), KEY = 1000001;

class H{
private:
    unsigned int lst[KEY], val[N+1], urm[N+1];
    unsigned int nr;
public:
    bool contains(unsigned int element)
    {
        unsigned int place = lst[element%KEY];
        while(place != 0 && val[place] != element)
        {
            place = urm[place];
        }
        return (place != 0);
    }
    void push(unsigned int element)
    {
        unsigned int place = element%KEY;
        val[++nr] = element;
        urm[nr] = lst[place];
        lst[place] = nr;
    }
    void pop(unsigned int element)
    {
        unsigned int place = element%KEY;
        if(element == val[lst[place]])
        {
            lst[place] = urm[lst[place]];
            return;
        }
        place = lst[place];
        while(urm[place] != 0 && val[urm[place]] != element)
        {
            place = urm[place];
        }
        if(val[urm[place]] == element)
        {
            urm[place] = urm[urm[place]];
        }
    }
};

int main()
{
    H hashLeft, hashRight;
    unsigned int left = 0, right = 0, dLeft = 0, dRight = 0;
    unsigned int n, l, u, result;

    in >> n >> l >> u;

    unsigned int v[n+1], i;

    bool na = false;

    while(dLeft < l && left < n)
    {
        left++;
        if(!hashLeft.contains(v[left]))
        {
            dLeft++;
        }
        hashLeft.push(v[left]);
    }
    while(dRight <= u && right <= n)
    {
        right++;
        if(!hashRight.contains(v[right]))
        {
            dRight++;
        }
        hashRight.push(v[right]);
    }
    hashRight.pop(v[right]);
    right--;
    dRight--;
    result = right - left + 1;
    for(i = 2; i <= n && !na; i++)
    {
        hashLeft.pop(v[i-1]);
        hashRight.pop(v[i-1]);
        if(!hashLeft.contains(v[i-1]))
        {
            dLeft--;
            while(dLeft < l && left < n)
            {
                left++;
                if(!hashLeft.contains(v[left]))
                {
                    dLeft++;
                }
                hashLeft.push(v[left]);
            }
            if(dLeft < l && left == n)
            {
                na = true;
            }
        }
        if(!hashRight.contains(v[i-1]))
        {
            dRight--;
            while(dRight <= u && right <= n)
            {
                right++;
                if(!hashRight.contains(v[right]))
                {
                    dRight++;
                }
                hashRight.push(v[right]);
            }
        }
        hashRight.pop(v[right]);
        right--;
        dRight--;
        result += right - left + 1;
    }
    out << result;
    return 0;
}