// #include <bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<map>
#include <vector>
#include<stack>
#include<cstring>
#include <set>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <utility>
#include <cmath>
#include <queue>
#include <iomanip>

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
#define vll vector<ll>
#define vpll vector<pair<ll ,ll > >
#define pb push_back
#define MOD 1000000007
#define inf 100000000000000000
#define ios ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define all(v) v.begin(),v.end()
#define fst first
#define scd second
#define fr(i,n) for(ll (i) = 0 ; (i) < (n) ; ++(i))
#define fr1(i,n) for(ll (i) = 1 ; (i) <= (n) ; ++(i))
#define frr(i,n) for(ll (i) = (n)-1 ; (i)>=0 ; --(i))
#define frab(i,a,b,c) for(ll (i) = a ; (i) < (b) ; (i)+=(c))
#define print(v) for( auto it: v) cout<<it<<" "
#define mst(A) memset( (A) , 0 , sizeof(A) )


//////////////////////////////////////////////////////////////////////////
//------------------TRACE--------------------------------//
template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os << "(" << p.first << ", " << p.second << ")";
    return os;
}

template<class T>
ostream& operator <<(ostream& os, const vector<T>& v) {
    os << "{";
    for (int i = 0; i < (int)v.size(); i++) {
        if (i)os << ", ";
        os << v[i];
    }
    os << "}";
    return os;
}

#ifdef LOCAL
#define cerr cout
#else
#endif

#define TRACE

#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
    cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define trace(...)
#endif
//////////////////////////////////////////////////////

bool cmp(const pair<ll, ll> &a, const pair<ll, ll> &b)
{
    if (a.first == b.first)
        return (a.scd >= b.scd);
    return (a.first < b.first);
}
vll primes;
vll seive;
void Seive(ll n) {
    seive.resize(n + 5, 1);
    seive[1] = 0, seive[0] = 0;
    for ( int i = 2; i * i < n + 5; i++) {
        if (seive[i]) {
            for (int j = 2 * i; j < n + 5; j += i) {
                seive[j] = 0;
            }
        }
    }
}
ll power(ll x, ll y , ll m = MOD) {
    long long int res = 1;
    x = x % m;
    while (y > 0) {
        if (y & 1)
            res = (res * x) % m;
        y = y >> 1;
        x = (x * x) % m;
    }
    return res;
}
ll modinv(ll x , ll mod = MOD) {
    return power(x , mod - 2 , mod);
}
ll n, m;
ll A[300060];
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("/home/aman/Documents/compwtitive_coding/Competitive-coding-codes/in.txt", "r", stdin);
    freopen("/home/aman/Documents/compwtitive_coding/Competitive-coding-codes/output.txt", "w", stdout);
#endif
    ll  k, t, a, b, c, d;
    t = 1;

    while (t--) {

        cin >> n;
        fr(i, n) {
            cin >> A[i];
        }
        sort(A, A + n);
        c = 0;
        vector<vector<ll> > aa;
        fr(i, n) {
            for (int j = i + 1; j < n ; j++) {
                for ( int k = j + 1; k < n ; k++) {
                    if ( A[i] != A[j] && A[i] != A[k] && A[j] != A[k]) {
                        if (A[i] + A[j] > A[k]) {
                            // vll x = {A[i], A[j], A[k]};
                            // aa.pb(x);
                            // // cout << A[i] << " " << A[i] << " " << A[k] << endl;
                            c++;
                        }
                    }


                }
            }
        }
        // sort(all(aa));
        // auto ip =  unique(aa.begin(), aa.begin() + aa.size());

        // // Resizing the vector so as to remove the undefined terms
        // aa.resize(distance(aa.begin(), ip));
        cout << c << endl;

    }
}








Measured memory_bytes: 3644