import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        List<Integer> sticks = new ArrayList<Integer>();
        for(int i = 0; i< N; i++){
            sticks.add(scan.nextInt());
        }

        scan.close();
        int count = sticks.size();
        int ans = 0;

        if (count < 3){
            System.out.println(0);
            return;
        }

        for (int i = 0; i < count - 2; i++){
            for (int j = i + 1; j < count - 1; j++){
                for (int k = j + 1; k < count; k++){

                    // 異なる数字であるか
                    if(sticks.get(i) == sticks.get(j) || sticks.get(j) == sticks.get(k) || sticks.get(k) == sticks.get(i)){
                        continue;
                    }

                    // 三角形の成立条件を満たすか
                    if(sticks.get(i) + sticks.get(j) > sticks.get(k) && sticks.get(j) + sticks.get(k) > sticks.get(i) && sticks.get(k) + sticks.get(i) > sticks.get(j)){
                        ans++;
                    }

                }
            }
        }

        System.out.println(ans);

    }

}


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        List<Integer> sticks = new ArrayList<Integer>();
        for(int i = 0; i< N; i++){
            sticks.add(scan.nextInt());
        }

        scan.close();
        int count = sticks.size();
        int ans = 0;

        for (int i = 0; i < count - 2; i++){
            for (int j = i + 1; j < count - 1; j++){
                for (int k = j + 1; k < count; k++){

                    // 異なる数字であるか
                    if(sticks.get(i) == sticks.get(j) || sticks.get(j) == sticks.get(k) || sticks.get(k) == sticks.get(i)){
                        continue;
                    }

                    // 三角形の成立条件を満たすか
                    if(sticks.get(i) + sticks.get(j) > sticks.get(k) && sticks.get(j) + sticks.get(k) > sticks.get(i) && sticks.get(k) + sticks.get(i) > sticks.get(j)){
                        ans++;
                    }

                }
            }
        }

        System.out.println(ans);

    }

}


#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
#define deb(x) cout << #x << " " << x << endl;
#define debtwo(x,y) cout << #x << " " << x << ", " << #y << " " << y << endl;
#define mod 1000000000000000000

int main()
{
  int n;
  cin >> n;
  vector<ll> arr(n);

  for (int i = 0; i < n; i++) cin >> arr[i];

  sort(arr.begin(), arr.end());
  // for (int i = 0; i < n; i++) cout << arr[i] << " ";
  // cout << endl;
  int c = 0;
  for (int i = 0; i < arr.size() - 2; i++) {
    auto it = upper_bound(arr.begin(), arr.end(), arr[i]);
    if (it == arr.end()) break;
    while (it != arr.end()) {
      int sec = *it;
      it++;
      auto it2 = it;
      //debtwo(arr[i], sec)
      while (it2 != arr.end() && (*it2 < arr[i] + sec)) {
        if (*it2 != sec)c++;
        it2++;
      }
      //deb(c) //1 4 6 6 6 6 8 9 9 10
    }
    // while (i < arr.size() && arr[i + 1] == arr[i]) {
    //   // debtwo(arr[i], arr[i + 1])
    //   // cout << i << endl;
    //   i++;
    // }

  }
  cout << c;
}


#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int a[300];

bool judge(int x, int y, int z) {
    if (x == y || x == z || y == z)
        return false;
    if (x + y > z && (abs(x  - y) < z)) {
        return true;
    }
    return false;
}

int main() {
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            for (int k = j + 1; k <= n; k++) {
                if (judge(a[i], a[j], a[k])) {
                    ans++;
                }
            }
        }
    }
    cout << ans << endl;
}


#include <bits/stdc++.h>

using namespace std;

int main() {
	int n;

	cin >> n;

	vector <int> L(n);

	for (int i = 0; i < n; i++) {
		cin >> L[i];
	}

	sort(L.begin(), L.end());

	int ans = 0;

	for (int i = 0; i < n; i++) {
		for (int j = i+1; j < n; j++) {
			if (L[i] == L[j]) {
				continue;
			}
			for (int k = j+1; k < n; k++) {
				if (L[j] == L[k]) {
					continue;
				}
				if (L[i] + L[j] > L[k]) {
					ans++;
				}
			}
		}
	}

	cout << ans << "\n";

	return 0;
}


#include<cstdio>
#include<iostream>
#include<string>
#include<algorithm>
#include<stdio.h>
#include<locale.h>
#include<math.h>
#include<set>
#include<stack>
#include<queue>
using namespace std;
int main()
{
 int n,l[102],ans=0;
 scanf("%d",&n);
 for(int i=0;i<n;i++)
 {
	scanf("%d",&l[i]);
 }
 for(int i=0;i<n;i++)
 {
	for(int j=i+1;j<n;j++)
	{
		for(int k=j+1;k<n;k++)
		{
		 if(l[i]+l[j]>l[k]&&l[i]+l[k]>l[j]&&l[j]+l[k]>l[i]){if(l[i]==l[j]&&l[j]==l[k]){}else{ans++;}}
		}
	}
 }
 printf("%d",ans);
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int n;
    cin >> n;

    int l[n];
    for(int i = 0; i < n; i++)
        cin >> l[i];

    int cnt = 0;
    for(int i = 0; i < n; i++){
        for(int j = i + 1; j < n; j++){
            for(int k = j + 1; k < n; k++){
                if(l[i] != l[j] && l[j] != l[k] && l[k] != l[i])
                    cnt++;
            }
        }
    }

    cout << cnt << endl;

    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define PI acos(-1)
using namespace std;
const ll N = 1e5+100;
const ll MOD = 1e9+7;

ll n,m,T;
ll l[110];
int main()
{
	/*scanf("%d",&T);
	while(T--)
	{

	 }
	 */
	scanf("%lld",&n);
	for(ll i=1;i<=n;i++)
	{
		scanf("%lld",&l[i]);
	}
	ll ans = 0;
	for(ll i=1;i<=n;i++)
	for(ll j=i+1;j<=n;j++)
	for(ll k=j+1;k<=n;k++)
	{
		ll a = l[i], b = l[j], c = l[k];
		if(a+b>c&&a+c>b&&b+c>a)	ans++;

	}
	printf("%lld\n",ans);
	return 0;
}


#include<stdio.h>
#include<stdlib.h>

int compare_int(const void *a, const void *b)
{
  return *(int*)a-*(int*)b;
}

int main()
{
  int n,i,j,k;
  int l[101];
  int ans=0;
  scanf("%d",&n);
  for(i=0;i<n;i++){
    scanf("%d",&l[i]);
  }
  qsort(l,n,sizeof(int),compare_int);
  for(i=0;i<n;i++){
    for(j=i+1;j<n;j++){
      for(k=j+1;k<n;k++){
        if( (l[i]==l[j]) || (l[j]==l[k]) || (l[k]==l[i]) ) continue;
        if( l[i]+l[j]>l[k] ) ans++;
      }
    }
  }
  printf("%d",ans);
  return 0;
}


#include <stdio.h>
int main(void){
    // Your code here!
    int n, i, ii, iii, ans = 0;
    long long int l[101], tmp, sum;

    scanf("%d", &n);
    for (i = 0; i < n; i++)
        scanf("%lld", l + i);
    for (i = 0; i < n; i++)
        for (ii = i + 1; ii < n; ii++)
            for (iii = ii + 1; iii < n; iii++)
                if (l[i] != l[ii] && l[i] != l[iii] && l[ii] != l[iii])
                {
                    tmp = l[i];
                    if (l[ii] > tmp)
                        tmp = l[ii];
                    if (l[iii] > tmp)
                        tmp = l[iii];
                    sum = l[i] + l[ii] + l[iii];
                    if (sum - tmp * 2 > 0)
                        ans++;
                }
    printf("%d", ans);

}


#include <stdio.h>
#include <stdlib.h>
int desc(const void *x, const void *y){
    return *(int *)x - *(int *)y;
}
int main(void){
    int n,i,j,k,cnt=0;
    scanf("%d",&n);
    int l[n];
    for(i=0;i<n;i++) scanf("%d",&l[i]);
    qsort(l,n,sizeof(int),desc);
    for(i=0;i<n;i++){
        for(j=0;j<i;j++){
            for(k=0;k<j;k++){
                if(l[i]!=l[j] && l[j]!=l[k] && l[k]+l[j]>l[i]) cnt++;
            }
        }
    }
    printf("%d",cnt);
    return 0;
}


#include<stdio.h>

int main(void){
  int n,tmp,c=0;
  scanf("%d",&n);
  int l[n];
  for(int i=0;i<n;i++){
    scanf("%d",&l[i]);
  }

  for(int i=0;i<n;i++){
    for(int j=i+1;j<n;j++){

      if(l[i]>l[j]){
        tmp=l[i];
        l[i]=l[j];
        l[j]=tmp;
      }
    }
  }

  for(int i=0;i<n;i++){
    for(int j=i+1;j<n;j++){
      for(int k=j+1;k<n;k++){
        if(l[i]!=l[j] && l[j]!=l[k] && l[k]+l[j]>l[i]){
          c++;
        }
      }
    }
  }
  printf("%d\n",c);
return 0;
}


#include <stdio.h>
#include <stdlib.h>

int main(){

int N,L[N+1],i=0,j=1,num=0,A=0,B=0;

scanf("%d",&N);

for(i;i<N;i++){
    scanf("%d",&L[i]);
}

for(j;j < (N-1);j++){
    for(int k=j+1;k<N;k++){
        for(int l=k+1;l<(N+1);l++){

            if((L[j-1] != L[k-1]) & (L[j-1] != L[l-1]) & (L[k-1] != L[l-1])){

                if((L[j-1] < (L[k-1]+L[l-1])) & (L[k-1] < (L[j-1]+L[l-1])) & (L[l-1] < (L[j-1]+L[k-1]))){
                    num++;
                    }
                else{num+=0;}
            }
            else{num+=0;}
        }
    }

}

printf("%d",num);

return 0;

}


#include<stdio.h>
int buble(int a,int b[200]){
  int j,i,tmp;
  for(i=0;i<a;i++){
    for(j=0;j<a;j++){
      if(b[i]>b[j]){
        tmp=b[i];
        b[i]=b[j];
        b[j]=tmp;
      }
    }
  }
  return b;
}

int main(){
  int n,a,b,c,k,l,d,e,f,p,count=0;
  scanf("%d",&n);
  for(p=0;p<=n;p++){
    scanf("%d,&l[p]");
  }
  l[200]=buble(n,l);
  p=(n*n*n-3*n*n+2*n)/6;
  for(d=0;d<n;d++){
    for(e=d+1;e<n;e++){
      for(f=e+1;f<n;f++){
        if(l[d]>=l[e]+l[f]||l[d]==l[e]||l[e]==l[f]){
          count++;
        }
      }
    }
  }
  count=p-count;
  printf("%d",count);
  return 0;
}


function Main(input) {
  input=input.split("\n");
  const N=input[0]-0;
  var array=input[1].split(' ').map(e=>{
    return e-0;
  }).sort((a,b)=>{
    return a-b;
  });
  var ans=0;
  //console.log(array);
  for(var i=0;i<N-2;i++){
    for(var j=i+1;j<N-1;j++){
      for(var k=j+1;k<N;k++){
        if(array[i]===array[j]){
          break;
        }
        if(array[j]===array[k]){
          continue;
        }
        if(array[i]+array[j]<=array[k]){
          break;
        }
        //console.log(i,j,k);
        ans++;
      }
    }
  }
  console.log(ans);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input){
  input = input.split('\n');
  const N = Number(input[0]);
  const list = input[1].split(' ').map(Number);

  let sum = 0;
  for(let i=0; i<N; i++){
    for(let j=i+1; j<N; j++){
      for(let k=j+1; k<N; k++){
        const a = list[i];
        const b = list[j];
        const c = list[k];
        if(a!=b &&  b!=c && c!=a){
          if(
              ((a+b) > c)
            && ((b+c) > a)
            && ((c+a) > b)
          ){
            sum++;
          }
        }
      }
    }
  }

  console.log(sum);

}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim());


"use strict";
var input=require("fs").readFileSync("/dev/stdin","utf8");
var cin=input.split(/ |\n/),cid=0;
function next(){return +cin[cid++];}
function nextstr(){return cin[cid++];}
function nextbig(){return BigInt(cin[cid++]);}
function nexts(n,a){return a?cin.slice(cid,cid+=n):cin.slice(cid,cid+=n).map(a=>+a);}
function nextm(h,w,a){var r=[],i=0;if(a)for(;i<h;i++)r.push(cin.slice(cid,cid+=w));else for(;i<h;i++)r.push(cin.slice(cid,cid+=w).map(a=>+a));return r;}
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill().map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill().map(x=>"+r+")";return eval(r);}

var myOut = main();
if(myOut !== undefined)console.log(String(myOut));

function main(){
  var n = next();
  var l = nexts(n).sort((a,b)=>a-b);
  var ans = 0;
  for(var i = 0; i < n; i++)
  for(var j = i+1; j < n; j++)
  for(var k = j+1; k < n; k++){
    if(l[i] === l[j] || l[j] === l[k])continue;
    if(l[i] + l[j] > l[k])ans++;
  }
  return ans;
}


function Main(input){
  input = input.split("\n");//[N, L L L L L,]数字として認識していない状態
  const hairetu = input[1].split(" ");//[L,L,L,L,L,]
  let result = 0;

  for(let i = 0; i < hairetu.length; i++){
   for(let j = i+1; j < hairetu.length; j++){
    for(let k = j +1; k < hairetu.length; k++){
      if(hairetu[i] < hairetu[j] + hairetu[k] &&
        hairetu[j] < hairetu[i] + hairetu[k]&&
        hairetu[k] < hairetu[i] + hairetu[j]
        && hairetu[i] !== hairetu[j] && hairetu[j] !== hairetu[k] && hairetu[i] !== hairetu[k]){
             result++;}//要素3つが三角形の成立条件を満たしているか
      }
    }
   }
    console.log(result);
  }
  Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input){
  input = input.split("\n");//[N, L L L L L,]数字として認識していない状態
  const ls = parseInt(input[1], 10);
  const hairetu = ls.split(" ");//[L,L,L,L,L,]
  let result = 0;

  for(let i = 0; i < hairetu.length; i++){
   for(let j = i+1; j < hairetu.length; j++){
    for(let k = j +1; k < hairetu.length; k++){
      if(hairetu[i] < hairetu[j] + hairetu[k] &&
        hairetu[j] < hairetu[i] + hairetu[k]&&
        hairetu[k] < hairetu[i] + hairetu[j]
        && hairetu[i] !== hairetu[j] && hairetu[j] !== hairetu[k] && hairetu[i] !== hairetu[k]){
             result++;}//要素3つが三角形の成立条件を満たしているか
      }
    }
   }
    console.log(result);
  }
  Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input){
  input = input.split("\n");//[N, L L L L L,]
  //const N = parseInt(input[0], 10);
  const hairetu = input[1].split(" ");//[L,L,L,L,L,]
  let result = 0;

  for(let i = 0; i < hairetu.length; i++){
   for(let j = i+1; j < hairetu.length; j++){
    for(let k = j +1; k < hairetu.length; k++){
      if(hairetu[i] < hairetu[j] + hairetu[k] &&
        hairetu[j] < hairetu[i] + hairetu[k]&&
        hairetu[k] < hairetu[i] + hairetu[j]
        && hairetu[i] !== hairetu[j] && hairetu[j] !== hairetu[k] && hairetu[i] !== hairetu[k]){
             result++;}//要素3つが三角形の成立条件を満たしているか
      }
    }
   }
    console.log(result);
  }
  Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var scanner = bufio.NewScanner(os.Stdin)

func nextStr() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() int {
	i, _ := strconv.Atoi(nextStr())
	return i
}

func main() {
	scanner.Split(bufio.ScanWords)

	n := nextInt()
	L := make([]int, n)

	for i := 0; i < n; i++ {
		L[i] = nextInt()
	}

	var ans int

	for i := 0; i < n-2; i++ {
		for j := i + 1; j < n-1; j++ {
			for k := j + 1; k < n; k++ {
				a, b, c := L[i], L[j], L[k]
				if a+b > c && b+c > a && c+a > b && a != b && b != c && c != a {
					ans++
				}
			}
		}
	}
	fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
)

var sc = bufio.NewScanner(os.Stdin)

func init() {
	buf := make([]byte, initialBufSize)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords)
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func main() {
	var N int = nextInt()
	var L []int = make([]int, N)
	for i := 0; i < N; i++ {
		L[i] = nextInt()
	}
	sort.Ints(L)
	var result int
	for i := 0; i < N; i++ {
		for j := i + 1; j < N; j++ {
			for k := j + 1; k < N; k++ {
				if L[i] != L[j] && L[j] != L[k] && L[k] != L[i] {
					if L[k] < L[i]+L[j] {
						result++
					}
				}
			}
		}
	}
	fmt.Println(result)
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
)

//Util
func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func maxInt(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func minInt(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func powInt(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	if x == 2 {
		return true
	}
	if x%2 == 0 {
		return false
	}

	b := true
	rootx := int(math.Sqrt(float64(x)))
	i := 3
	for i <= rootx {
		if x%i == 0 {
			b = false
			break
		}
		i += 2
	}
	return b
}

func PrimeFactors(n int) (pfs []int) {
	// Get the number of 2s that divide n
	for n%2 == 0 {
		pfs = append(pfs, 2)
		n = n / 2
	}

	// n must be odd at this point. so we can skip one element
	// (note i = i + 2)
	for i := 3; i*i <= n; i = i + 2 {
		// while i divides n, append i and divide n
		for n%i == 0 {
			pfs = append(pfs, i)
			n = n / i
		}
	}

	// This condition is to handle the case when n is a prime number
	// greater than 2
	if n > 2 {
		pfs = append(pfs, n)
	}

	return
}

func PrimeFactorsMap(n int) map[int]int {
	pfs := map[int]int{}
	// Get the number of 2s that divide n
	for n%2 == 0 {
		if _, ok := pfs[2]; ok {
			pfs[2]++
		} else {
			pfs[2] = 1
		}
		//pfs = append(pfs, 2)
		n = n / 2
	}

	// n must be odd at this point. so we can skip one element
	// (note i = i + 2)
	for i := 3; i*i <= n; i = i + 2 {
		// while i divides n, append i and divide n
		for n%i == 0 {
			if _, ok := pfs[i]; ok {
				pfs[i]++
			} else {
				pfs[i] = 1
			}
			n = n / i
		}
	}

	// This condition is to handle the case when n is a prime number
	// greater than 2
	if n > 2 {
		if _, ok := pfs[n]; ok {
			pfs[n]++
		} else {
			pfs[n] = 1
		}
	}

	return pfs
}

func sumInts(x []int) int {

	total := 0
	for _, v := range x {
		total += v
	}

	return total
}

func swap(a int, b int) (int, int) {
	return b, a
}

func gcd(a, b int) int {
	if b == 0 {
		return a
	}
	return gcd(b, a%b)
}

func lcm(a, b int) int {

	return a / b * gcd(a, b)

}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

func main() {
	sc.Split(bufio.ScanWords)
	N := nextInt()
	L := make([]int, N)

	if N < 3 {
		fmt.Println(0)
		return
	}

	for i := 0; i < N; i++ {
		L[i] = nextInt()
	}

	sort.Ints(L)

	ans := 0
	for i := 0; i < N-2; i++ {
		for j := i; j < N-1; j++ {
			for k := j; k < N; k++ {
				if L[i] == L[j] || L[j] == L[k] {
					continue
				}
				if L[i]+L[j] > L[k] && L[j]+L[k] > L[i] && L[k]+L[i] > L[j] {
					ans++
				}
			}
		}
	}
	fmt.Println(ans)
}


package main

import (
	"fmt"
)

func main() {
	var N int //読み込む数
	var sum int
	var L [100]int
	fmt.Scan(&N)
	for a := 0; a < N; a++ {
		fmt.Scan(&L[a])
	}
	//辺の読み取り
	for i := 0; i < N; i++ {
		for k := i + 1; k < N; k++ {
			for j := k + 1; j < N; j++ {
				if L[i] < L[k]+L[j] || L[k] < L[j]+L[i] || L[j] < L[i]+L[k] || L[i] != L[j] || L[j] != L[k] || L[k] != L[i] {
					sum++
				}
			}
		}
	}
	fmt.Printf("%d", sum)
}


package main

import (
	"fmt"
)

func main() {
	var N int //読み込む数
	var sum int
	fmt.Scanf("%d", &N)
	var L [100]int
	for i := 0; i < N; i++ {
		fmt.Scan("%d", &L[i])
	}
	//辺の読み取り
	for i := 0; i < N; i++ {
		for k := i + 1; k < N; k++ {
			for j := k + 1; j < N; j++ {
				if L[i] < L[k]+L[j] || L[k] < L[j]+L[i] || L[j] < L[i]+L[k] || L[i] != L[j] || L[j] != L[k] || L[k] != L[i] {
					sum++
				}
			}
		}
	}
	fmt.Printf("%d", sum)
}


package main

import (
	"fmt"
)

func main() {
	var N int //読み込む数
	var sum int
	fmt.Scan(&N)
	var L [100]int
	for i := 0; i < N; i++ {
		fmt.Scan(&L[i])
	}
	//辺の読み取り
	for i := 0; i < N; i++ {
		for k := i + 1; k < N; k++ {
			for j := k + 1; j < N; j++ {
				if L[i] < L[k]+L[j] || L[k] < L[j]+L[i] || L[j] < L[i]+L[k] || L[i] != L[j] || L[j] != L[k] || L[k] != L[i] {
					sum++
				}
			}
		}
	}
	fmt.Printf("%d", sum)
}


N = $stdin.gets.to_i
L = $stdin.gets.split.map {|i| i.to_i }
Lsort = L.sort.reverse
Llen = L.length

cnt = 0
0.upto(Llen - 3) do |i|
  li = Lsort[i]
  (i + 1).upto(Llen - 2) do |j|
    lj = Lsort[j]
    next if li == lj
    (j + 1).upto(Llen - 1) do |k|
      lk = Lsort[k]
      next if lj == lk
      break if li >= lj + lk
      cnt += 1
    end
  end
end
puts cnt


# 棒の本数
n = gets.to_i
# 棒の長さ
a = gets.split.map(&:to_i).sort
# 答えの変数
sum = 0
# 全探索
(n - 2).times do |i|
  ((i + 1)...(n - 1)).each do |j|
    next if a[i] == a[j]
    ((j + 1)...n).each do |k|
      next if a[i] + a[j] <= a[k] || a[j] == a[k]
      sum += 1
    end
  end
end
puts sum


N = gets.to_i
L = gets.split.map(&:to_i)
L.sort!
r = 0
(0 .. N - 3).each{|i|
    (i + 1 .. N - 2).each{|j|
        next if L[i] == L[j]
        (j + 1 .. N - 1).each{|k|
            next if L[j] == L[k]
            break if L[i] + L[j] <= L[k]
            r += 1
        }
    }
}
puts r


n = gets.chomp.to_i
list = gets.chomp.split(' ').map(:&to_i).sort
count = 0
n.times do |i|
  (i+1..(n-1)).each do |j|
    (j+1..(n-1)).each do |k|
      if list[i] != list[j] && list[j] != list[k] && list[i] != list[k] && list[i] + list[j] > list[k]
        count += 1
      end
    end
  end
end

print count


n = gets.to_i
a = gets.split.map(&:to_i).sort
ans = 0
for i in 0...n-2
  for j in i+1...n-1
    for k in j+1...n
      if a[i]+a[j]>a[k]
        ans += 1
      end
    end
  end
end
puts ans


### SNIPPET
  # n = gets.split.map(&:to_i)
  # array = n.times.map { gets.split.map(&:to_i) }
  # [].all?(&:even?)
  # a = [*1..m].repeated_combination(n).to_a
  # [1,2,3,4,5].select { |num| num.even? }  # => [2, 4]
  # ["a","a","b"].group_by(&:itself).map{|k,v| [k, v.count]}.to_h #=> {"a"=>2, "b"=>1}
  # 切り捨て: .floor(2).to_f ,切り上げ： .ceil(2).to_f,四捨五入: round(2)
  # 3.upto(6) do |i|, 6.downto(3) do |i|
  # 公約数125.gcd(100)、公倍数125.lcm(100)
  # PI = Math::PI
  # 高さ = a * Math.sin(w / 180.0 * Math::PI), 底辺 = a * Math.cos(w / 180.0 * Math::PI)
  # def chmax(a, b) a > b ? a : b end
  # INF = Float::INFINITY
  # def chmin(a, b) a < b ? a : b end

n = gets.to_i
l = gets.split.map(&:to_i)

s = Set.new
count = 0
n.times do |i|
  n.times do |j|
    n.times do |k|
      next if l[i]==l[j] || l[j]==l[k] || l[k]==l[i]
      if s.add?([i,j,k].sort)
        array = [l[i], l[j], l[k]].sort
        if array[0] + array[1] > array[2] &&
           array[0] < array[1] + array[2] &&
           array[0] + array[2] > array[1]
          count += 1
        end
      end
    end
  end
end

puts count


#[allow(unused_imports)]
use {
   proconio::{fastout, input, marker::*},
   std::cmp::*,
   std::collections::*,
};

#[fastout]
fn main() {
   input! {
      n: usize,
      mut l: [usize;n]
   }
   l.sort();
   let mut ans = 0;
   for i in 0..n {
      for j in i+1..n {
         if l[i] == l[j] {
            continue;
         }
         for k in j+1..n {
            if l[j] == l[k] {
               continue;
            }
            if l[i] + l[j] > l[k] {
               ans += 1;
            }
         }
      }
   }
   println!("{}", ans);
}


use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        n: usize,
        l: [usize; n]
    }

    let mut cnt = 0;
    for i in 0..n {
        for j in (i + 1)..n {
            for k in (j + 1)..n {
                if l[i] == l[j] || l[j] == l[k] || l[k] == l[i] {
                    continue;
                }
                if l[k] < l[i] + l[j] && l[i] < l[j] + l[k] && l[j] < l[k] + l[i] {
                    cnt += 1;
                }
            }
        }
    }
    println!("{}", cnt);

}


use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        n: usize,
        l: [i64; n],
    }

    let mut cnt = 0;
    for i in 0..n {
        for j in (i + 1)..n {
            for k in (j + 1)..n {
                if l[i] == l[j] || l[j] == l[k] || l[k] == l[i] {
                    continue;
                }
                if l[i] + l[j] > l[k] && l[j] + l[k] > l[i] && l[k] + l[i] > l[j] {
                    cnt += 1;
                }
            }
        }
    }

    println!("{}", cnt);
}


#[allow(unused_imports)]
use proconio::{fastout, input, marker::*};

#[fastout]
fn main() {
    input! {
        n: usize,
        l: [u64; n],
    }

    let mut ans = 0;

    for i in 0..(n-2) {
        for j in (i+1)..(n-1) {
            if l[i] == l[j] {
                continue;
            }
            for k in (j+1)..n {
                if l[i] == l[k] || l[j] == l[k] {
                    continue;
                }

                if l[k] < l[i] + l[j] && l[i] < l[j] + l[k] && l[j] <  l[k] + l[i] {
                    ans += 1;
                }
                // println!("{} {} {} = {} {} {}", i+1, j+1, k+1, l[i], l[j], l[k]);
            }
        }
    }

    println!("{}", ans);
}


#[allow(unused_imports)]
use proconio::{fastout, input, marker::*};

#[fastout]
fn main() {
    input! {
        n: usize,
        l: [u64; n],
    }

    let mut ans = 0;

    for i in 0..n-2 {
        for j in (i+1)..n-1 {
            if l[i] == l[j] {
                continue;
            }
            for k in (j+1)..n {
                if l[i] == l[k] || l[j] == l[k] {
                    continue;
                }

                if l[k] < l[i] + l[j] && l[i] < l[j] + l[k] && l[j] <  l[k] + l[i] {
                    ans += 1;
                }
                // println!("{} {} {} = {} {} {}", i+1, j+1, k+1, l[i], l[j], l[k]);
            }
        }
    }

    println!("{}", ans);
}


use proconio::input;

fn main() {
    input! {
        n: usize,
        l: [u64; n],
    }

    let mut ans = 0;

    for i in 0..n-2 {
        for j in i+1..n-1 {
            if l[i] == l[j] {
                continue;
            }
            for k in j+1..n {
                if l[i] == l[k] || l[j] == l[k] {
                    continue;
                }

                if l[k] < l[i] + l[j] && l[i] < l[j] + l[k] && l[j] <  l[k] + l[i] {
                    ans += 1;
                }
                // println!("{} {} {} = {} {} {}", i+1, j+1, k+1, l[i], l[j], l[k]);
            }
        }
    }

    println!("{}", ans);
}


struct Scanner {
    private var elements = [String]()
    private var index = 0

    mutating func peek() -> String {
        while elements.count == index {
            elements = readLine()!.split(separator: " ").map(String.init)
            index = 0
        }
        return elements[index]
    }

    mutating func next() -> String {
        let value = peek()
        index += 1
        return value
    }

    mutating func nextInt() -> Int {
        return Int(next())!
    }

    mutating func nextDouble() -> Double {
        return Double(next())!
    }
}

var scanner = Scanner()
let N = scanner.nextInt()
let L = (0 ..< N).map { _ in scanner.nextInt() }.sorted()

var answer = 0
for i in 0 ..< N {
    for j in i + 1 ..< N {
        for k in j + 1 ..< N {
            guard L[i] != L[j] && L[i] != L[k] && L[j] != L[k] else { continue }
            if L[i] + L[j] > L[k] {
                answer += 1
            }
        }
    }
}
print(answer)


let N = Int(readLine()!)!
if N < 3 {
    print(0)
} else {
    var L: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
    L.sort()
    var cou: Int = 0
    for i in 0..<N-2 {
        for j in i+1..<N-1 {
            for k in j+1..<N {
                if L[i] == L[j] || L[j] == L[k] { continue }
                if L[i] + L[j] > L[k] { cou += 1 }
            }
        }
    }
    print(cou)
}


let _ = Int(readLine()!)!
let LN = readLine()!.split(separator: " ").compactMap { Int($0) }.sorted()

var result = 0
for i in 0..<LN.count {
    let c = LN[LN.count - 1 - i]

    for j in (i+1)..<LN.count {
        let b = LN[LN.count - 1 - j]

        for z in (j+1)..<LN.count {
            let a = LN[LN.count - 1 - z]

            if a != b, b != c, a + b > c {
                result += 1
            }
        }
    }
}

print(result)


import Foundation
let main: () = {
    let N = nextInt()
    let L = listOfInt().sorted()
    var ans = 0
    for i in 0 ..< N - 2 {
        for j in i + 1 ..< N - 1 {
            for k in j + 1 ..< N {
                if L[i] + L[j] > L[k] {
                    if L[i] == L[j] { continue }
                    if L[i] == L[k] { continue }
                    if L[j] == L[k] { continue }
//print("\(L[i]) \(L[j]) \(L[k])")
                    ans += 1}
                else { break }
            }
        }
    }
    print(ans)
}()

//----------------------------------

let dx = [1, 0, -1, 0] //[1, 0, -1, 0, -1,  1, -1, 1]
let dy = [0, 1, 0, -1] //[0, 1, 0, -1, -1, -1,  1, 1]

@inlinable func gcd(_ a: Int, _ b: Int) -> Int { (b > 0) ? gcd(b, a % b) : a }
@inlinable func lcm(_ a: Int, _ b: Int) -> Int { a / gcd(a, b) * b }

//----------------------------------

infix operator  =~ : ComparisonPrecedence
infix operator !=~ : ComparisonPrecedence
func =~ <T: FixedWidthInteger>(left: T, right: Range<T>) -> Bool { right ~= left }
func !=~ <T: FixedWidthInteger>(left: T, right: Range<T>) -> Bool { !(right ~= left) }
func =~ <T: FixedWidthInteger>(left: T, right: ClosedRange<T>) -> Bool { right ~= left }
func !=~ <T: FixedWidthInteger>(left: T, right: ClosedRange<T>) -> Bool { !(right ~= left) }

func =~ <T: Collection > (left: T.Element, right: T) -> Bool where T.Element : Equatable { right.contains(left) }
func !=~ <T: Collection > (left: T.Element, right: T) -> Bool where T.Element : Equatable { !right.contains(left) }

infix operator /^ : MultiplicationPrecedence
infix operator /^= : AssignmentPrecedence
func /^ <T: FixedWidthInteger>(left: T, right: T) -> T { (left + (right - 1)) / right }
func /^= <T: FixedWidthInteger>(left: inout T, right: T) { left = (left + (right - 1)) / right }

@inlinable func chmax<T: Comparable>(_ m: inout T, _ q: T) { if (m < q) { m = q } }
@inlinable func chmin<T: Comparable>(_ m: inout T, _ q: T) { if (m > q) { m = q } }
@inlinable func chRmax<T: Comparable>(_ m: inout T, _ q: T) -> Bool { if (m < q) { m = q; return true } else { return false } }
@inlinable func chRmin<T: Comparable>(_ m: inout T, _ q: T) -> Bool { if (m > q) { m = q; return true } else { return false } }

prefix operator *
prefix func * <T> (a: [T]) -> (T, T) { (a[0], a[1]) }
prefix func * <T> (a: [T]) -> (T, T, T) { (a[0], a[1], a[2]) }
prefix func * <T> (a: [T]) -> (T, T, T, T) { (a[0], a[1], a[2], a[3]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T) { (a[0], a[1], a[2], a[3], a[4]) }
prefix func * <T> (a: [T]) -> (T, T, T, T, T, T) { (a[0], a[1], a[2], a[3], a[4], a[5]) }

func printErr(_ str: String, terminator: String = "\n") {
    let s = str + terminator
    FileHandle.standardError.write(s.data(using: .utf8)!)
    FileHandle.standardError.synchronizeFile()
}

@inlinable func next() -> String { readLine()! }
@inlinable func nextInt() -> Int { Int(next())! }
@inlinable func nextDouble() -> Double { Double(next())! }
@inlinable func listOfString() -> [String] { next().split(separator: " ").map(String.init) }
@inlinable func listOfInt() -> [Int] { listOfString().map { Int($0)! } }
@inlinable func listOfInt(_ offset: Int = 0) -> [Int] { listOfString().map { Int($0)! + offset } }
@inlinable func listOfInt(_ offsets: Int ...) -> [Int] { listOfString().enumerated().map { Int($0.element)! + offsets[$0.offset % offsets.count] } }
@inlinable func listOfDouble(_ offset: Double = 0.0) -> [Double] { listOfString().map { Double($0)! + offset } }
@inlinable func listOfDouble(_ offsets: Double ...) -> [Double] { listOfString().enumerated().map { Double($0.element)! + offsets[$0.offset % offsets.count] } }

extension Int {
    init(s: String) { self.init(s)! }
    var isEven: Bool { self.isMultiple(of: 2) }
    var isOdd: Bool { !self.isEven }
    var isTrue: Bool { self != 0 }
    var isFalse: Bool { !self.isTrue }
    var toString: String { String(self) }
    var toChar: Character { Character(UnicodeScalar(UInt8(self))) }
}
func + (left: Int, right: Bool) -> Int { left + (right ? 1 : 0) }
extension Character {
    var asciiCode: Int { Int(self.asciiValue!) }
    var string: String { String(self) }
}
extension String {
    @inlinable subscript (position: Int) -> Character { self[self.index(self.startIndex, offsetBy: position)] }
    @inlinable func repeate(_ times: Int) -> String { String(repeating: self, count: times) }
    //  @inlinable subscript (n: Int) -> String { String(self[self.index(self.startIndex, offsetBy: n)]) }
    //  @inlinable subscript (n: Int) -> Int { Int(self[self.index(self.startIndex, offsetBy: n)].asciiValue!) }
    var toInt: Int { Int(self)! }
}
extension String { // VB like
    @inlinable func _index(_ position: Int) -> String.Index! {
        if !(0 ..< self.count ~= position) { return nil }
        return self.index(self.startIndex, offsetBy: position)
    }
    @inlinable func mid(from index: Int, length: Int) -> String! {
        if let startPosition = self._index(index) {
            if let endPosition = self._index(index + length - 1) {
                return String(self[startPosition...endPosition])
            } else {
                let endPosition = self.index(before: self.endIndex)
                return String(self[startPosition...endPosition])
            }
        }
        return ""
    }
    @inlinable func left(_ length: Int) -> String { String(self.prefix(length)) }
    @inlinable func right(_ length: Int) -> String { String(self.suffix(length)) }
}

extension Dictionary {
    @inlinable mutating func getOrSet(_ key: Key, _ defaultValue: () -> Value) -> Value {
        if let stored = self[key] { return stored }
        else {
            let newValue = defaultValue()
            self[key] = newValue
            return newValue
        }
    }
    @inlinable mutating func getOrElse(_ key: Key, _ defaultValue: () -> Value) -> Value {
        if let stored = self[key] { return stored } else { return defaultValue() }
    }
    @inlinable func containsKey(_ key: Key) -> Bool { self.keys.contains(key) }
}

extension Set {
    static func += (left: inout Set<Element>, right: Element) { left.insert(right) }
    static func -= (left: inout Set<Element>, right: Element) { left.remove(right) }
}

extension Array {
    static func += (left: inout Array<Element>, right: Element) { left.append(right) }
    init(_ size: Int, _ initValue: ((Int) -> Element)) {
        self = [Element]()
        for index in 0 ..< size {
            let value = initValue(index)
            self.append(value)
        }
    }
    init(_ size: Int, _ initValue: (() -> Element)) {
        self = [Element]()
        for _ in 0 ..< size {
            let value = initValue()
            self.append(value)
        }
    }
}
typealias IntArray = Array<Int>
typealias DoubleArray = Array<Double>
typealias BoolArray = Array<Bool>
typealias StringArray = Array<String>

extension Array where Element == Int {
    init(_ size: Int) {
        self = [Element](repeating: 0, count: size)
    }
}
extension Array where Element == Double {
    init(_ size: Int) {
        self = [Element](repeating: 0.0, count: size)
    }
}
extension Array where Element == Bool {
    init(_ size: Int) {
        self = [Element](repeating: false, count: size)
    }
}
extension Array where Element == String {
    init(_ size: Int) {
        self = [Element](repeating: "", count: size)
    }
}

extension Array {
    @inlinable func count(_ predicate: ((Element) -> Bool)) -> Int {
        var cnt = 0; for e in self { if (predicate(e)) { cnt += 1 } }
        return cnt
    }
    @inlinable func groupBy<K>(_ keySelector: (Element) -> K) -> [K : [Element]] {
        var destination = [K : [Element]]()
        for element in self {
            let key = keySelector(element)
            var list = destination.getOrSet(key) { [Element]() }
            list.append(element)
            destination[key] = list
        }
        return destination
    }
    @inlinable func groupByIndexed<K>(_ keySelector: (Element) -> K) -> [K : [Int]] {
        var destination = [K : [Int]]()
        for element in self.enumerated() {
            let key = keySelector(element.element)
            var list = destination.getOrSet(key) { [Int]() }
            list.append(element.offset)
            destination[key] = list
        }
        return destination
    }
}

extension Array {
    func binarySearch(_ element: Element, by compare: (Element, Element) -> Int, fromIndex: Int = 0, toIndex: Int = -1) -> Int {
        var low = fromIndex
        var high = (toIndex == -1) ? self.count - 1 : toIndex - 1
        while (low <= high) {
            let mid = (low + high) >> 1 // safe from overflows
            let midVal = self[mid]
            let cmp = compare(midVal, element)
            if (cmp < 0) { low = mid + 1 }          //-1
            else if (0 < cmp) { high = mid - 1 }    // 1
            else { return mid } // key found        // 0
        }
        return -(low + 1)  // key not found
    }
}
extension Array where Element : Comparable {
    func binarySearch(_ element: Element, fromIndex: Int = 0, toIndex: Int = -1) -> Int {
        var low = fromIndex
        var high = (toIndex == -1) ? self.count - 1 : toIndex - 1
        while (low <= high) {
            let mid = (low + high) >> 1 // safe from overflows
            let midVal = self[mid]
            if (midVal < element) { low = mid + 1 }
            else if (midVal > element) { high = mid - 1 }
            else { return mid } // key found
        }
        return -(low + 1)  // key not found
    }
}

extension Array where Element == Int {
    @inlinable func distinct() -> [Element] {
        var set = Set<Element>(), ary = [Element]()
        for n in self.indices { if !set.contains(self[n]) { ary.append(self[n]); set.insert(self[n]) } }
        return ary
    }
    @inlinable func any(_ predicate: (Element) -> Bool) -> Bool {
        var any = false; for element in self { if predicate(element) { any = true } }
        return any
    }
    @inlinable func all(_ predicate: (Element) -> Bool) -> Bool {
        self.allSatisfy(predicate)
    }
    @inlinable func sum() -> Element { self.reduce(0, +) }
    @inlinable func sum(by predicate: (Element) -> Element) -> Element {
        var sum = 0; for e in self { sum += predicate(e) }
        return sum
    }
    @inlinable func joinToString(_ sepatator: String = " ") -> String { self.map { String($0) }.joined(separator: sepatator) }
}

extension Array where Element == Double {
    @inlinable func sum() -> Element { self.reduce(0.0, +) }
    @inlinable func sum(by predicate: (Element) -> Element) -> Element {
        var sum = 0.0; for e in self { sum += predicate(e) }
        return sum
    }
    @inlinable func joinToString(_ sepatator: String = " ") -> String { self.map { String($0) }.joined(separator: sepatator) }
}
extension Array where Element == String {
    @inlinable func toIntDouble() -> (Int, Double) { (Int(self[0])!, Double(self[1])!) }
    @inlinable func toIntString() -> (Int, String) { (Int(self[0])!, self[1]) }
    @inlinable func toIntIntString() -> (Int, Int, String) { (Int(self[0])!, Int(self[1])!, self[2]) }
}

@inlinable func block( _ action: () -> Void) {
    action()
}
@inlinable func repeate(_ times1: Int, _ action: () -> Void) {
    for _ in 0 ..< times1 { action() }
}
@inlinable func repeate(_ times1: Int, _ action: (Int) -> Void) {
    for index1 in 0 ..< times1 {
        action(index1)
    }
}
@inlinable func repeate(_ times1: Int, _ times2: Int, _ action: (Int, Int) -> Void) {
    for index1 in 0 ..< times1 {
        for index2 in 0 ..< times2 {
            action(index1, index2)
        }
    }
}
@inlinable func repeate(_ times1: Int, _ times2: Int, _ times3: Int, _ action: (Int, Int, Int) -> Void) {
    for index1 in 0 ..< times1 {
        for index2 in 0 ..< times2 {
            for index3 in 0 ..< times3 {
                action(index1, index2, index3)
            }
        }
    }
}
@inlinable func repeate(_ times1: Int, _ times2: Int, _ times3: Int, _ times4: Int, _ action: (Int, Int, Int, Int) -> Void) {
    for index1 in 0 ..< times1 {
        for index2 in 0 ..< times2 {
            for index3 in 0 ..< times3 {
                for index4 in 0 ..< times4 {
                    action(index1, index2, index3, index4)
                }
            }
        }
    }
}

func measureTimeSeconds(block: (() -> Void)) -> Double {
    let startTime = Date()
    block()
    let duration = -startTime.timeIntervalSinceNow
    return duration
}

public class PriorityQueue<T> {
    private final var _heap: [T]
    private let compare: (T, T) -> Bool
    public init(_ compare: @escaping (T, T) -> Bool) {
        _heap = []
        self.compare = compare
    }
    public func push(_ newElement: T) {
        _heap.append(newElement)
        _ = siftUp(index: _heap.endIndex - 1)
    }
    public func peek() -> T? {
        if _heap.count == 0 { return nil }
        return _heap[0]
    }
    public func pop() -> T? {
        if _heap.count == 0 { return nil }
        _heap.swapAt(0, _heap.endIndex - 1)
        let pop = _heap.removeLast()
        _ = siftDown(index: 0)
        return pop
    }
    private func siftDown(index: Int) -> Bool {
        let left = index * 2 + 1
        let right = index * 2 + 2
        var smallest = index
        if left < _heap.count && compare(_heap[left], _heap[smallest]) { smallest = left }
        if right < _heap.count && compare(_heap[right], _heap[smallest]) { smallest = right }
        if smallest != index {
            _heap.swapAt(index, smallest)
            _ = siftDown(index: smallest)
            return true
        }
        return false
    }
    private func siftUp(index: Int) -> Bool {
        if index == 0 { return false }
        let parent = (index - 1) >> 1
        if compare(_heap[index], _heap[parent]) {
            _heap.swapAt(index, parent)
            _ = siftUp(index: parent)
            return true
        }
        return false
    }
}
extension PriorityQueue {
    public var count: Int { return _heap.count }
    public var isEmpty: Bool { return _heap.isEmpty }
    public func update<T2>(element: T2) -> T? where T2: Equatable {
        assert(element is T)  // How to enforce this with type constraints?
        for (index, item) in _heap.enumerated() {
            if (item as! T2) == element {
                _heap[index] = element as! T
                if siftDown(index: index) || siftUp(index: index) { return item }
            }
        }
        return nil
    }
    public func remove<T2>(element: T2) -> T? where T2: Equatable {
        assert(element is T)  // How to enforce this with type constraints?
        for (index, item) in _heap.enumerated() {
            if (item as! T2) == element {
                _heap.swapAt(index, _heap.endIndex - 1)
                _heap.removeLast()
                _ = siftDown(index: index)
                return item
            }
        }
        return nil
    }
    public var heap: [T] { return _heap }
    public func removeAll() { _heap.removeAll() }
    public func addAll(_ elements: [T]) { for e in elements { self.push(e) } }
}


// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

func readDoubles () -> [Double] {
    return readLine()!.split(separator: " ").map { Double($0)! }
}

func readDouble() -> Double{
    return Double(readLine()!)!
}

func readLines() -> [String] {
    return readLine()!.map { String($0) }
}

///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///最大公約数を返す
func gcd(_ array: [Int]) -> Int {
    var value = array[0]
    if array.count > 1 {
        for i in 1..<array.count {
            value = gcd(value, array[i])
        }
    }
    return value
}

///最小公倍数を返す
func lcm(_ m:Int, _ n:Int) -> Int {
    return m * n / gcd(m, n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = firstIndex(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(right:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = right

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}
// https://algo-logic.info/divisor/
/// 約数の配列を返す
func divisor(_ n:Int) -> [Int] {
    var ret = [Int]()
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            ret.append(i)
            if i * i != n {
                ret.append(n / i)
            }
        }
        i += 1
    }
    return ret.sorted()
}

func main() {
    let n = readInt()
    let l = readInts().sorted(by: >)
    //＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ここまで入力
    var ans = 0
    for i in 0..<n - 2 {
        for j in i+1..<n - 1 {
            for k in j+1..<n {
                if l[i] == l[j] || l[j] == l[k] || l[i] == l[k] { continue }
                if l[i] < l[j] + l[k] {
                    ans += 1
                }
            }
        }
    }
    print(ans)
}
main()


import Foundation

func main() {
    guard let line = readLine() , let line2 = readLine() else { return }
    let n = Int(line)!
    let l = line2.components(separatedBy: " ").compactMap() { Int($0) }
    guard n < 3 else {
        print(0)
        return
    }
    var count = 0
    for i in 0..<(n-2) {
        for j in (i+1)..<(n-1) {
            for k in (j+1)..<n {
                if check(j: l[i], k: l[j], l: l[k]) {
                    count += 1
                }
            }
        }
    }
    print(count)
}

func check(j: Int, k: Int, l: Int) -> Bool {
    return mul(a: j, b: k, c: l) && mul(a: k, b: l, c: j) && mul(a: l, b: j, c: k)
}

func mul(a: Int, b: Int, c: Int) -> Bool {
    return a + b > c && a != b
}

main()


import * as fs from "fs";

function strArr2numArr(strArr: string[]): number[] {
    let numArr: number[] = [];
    strArr.map((item) => {
        numArr.push(+item);
    });
    return numArr;
}

function isTriangle(a: number, b: number, c: number): boolean {
    if (a + b <= c) return false;
    if (b + c <= a) return false;
    if (c + a <= b) return false;
    return true;
}

const MOD: number = 1e9 + 7;

const input = fs.readFileSync("/dev/stdin", "utf8").split("\n");

let n: number = +input[0];
let L: number[] = strArr2numArr(input[1].split(" "));
L.sort();

let ans: number = 0;
for (let i = 0; i < n; i++) {
    for (let j = i + 1; j < n; j++) {
        for (let k = j + 1; k < n; k++) {
            if (L[i] == L[j] || L[j] == L[k] || L[k] == L[i]) continue;
            if (isTriangle(L[i], L[j], L[k])) {
                ans++;
            }
        }
    }
}

console.log(ans);


import * as fs from "fs";

const N = fs
  .readFileSync("/dev/stdin", "utf8")
  .split("\n")[0];

// inputで受け取り配列化する
const input = fs
  .readFileSync("/dev/stdin", "utf8")
  .split("\n")[1]
  .split(" ")
  .map(Number);

input.sort(function(a, b) {return b - a});
let ans = 0;

for(let i = 0; i < N; ++i) {
  for(let j = 0; j < i; ++j) {
    for(let k = 0; k < j; ++k) {
      if((input[i] != input[j])
        && (input[j] != input[k])
        && (input[i] + input[j] > input[k]) ){
      	ans++;
      }
	}
  }
}

console.log(ans);


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var n: number;
    var l: number[];
    var ans: number;
    // init
    n = Number(input[0]);
    l = input[1].split(" ").map(x => Number(x));
    // solve
    l.sort(Math_compareNumbers);
    ans = 0;
    for (var lx0 = 0; lx0 < l.length; lx0++) {
        for (var lx1 = lx0 + 1; lx1 < l.length; lx1++) {
            if (l[lx0] == l[lx1]) continue;
            for (var lx2 = lx1 + 1; lx2 < l.length; lx2++) {
                if (l[lx1] == l[lx2]) continue;
                if (l[lx0] + l[lx1] <= l[lx2]) break;
                ans++;
            }
        }
    }
    // answer
    console.log(ans);
}

// compare lib
function Math_compareNumbers(a: number, b: number): number {
    return a - b;
}

// graph lib
/*
function GRAPH_enumPattern(cur: number[], pat: number[][]): number[][] {
    var arr = [];
    for (var patx = 0; patx < pat.length; patx++) {
        var pos = [cur[0] + pat[patx][0], cur[1] + pat[patx][1]];
        arr.push(pos);
    }
    return arr;
}
*/

// math lib
/*
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}
*/

// union-find lib
/*
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}
*/

// entrypoint
function entrypoint() {
    try {
        // linux
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            main(input);
        });
    }
}
entrypoint();


import { readFileSync } from 'fs'
import { reverse } from 'dns'
import { start } from 'repl'

let lines: string[] = [];
const reader = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

reader.on('line', function (line: string) {
    lines.push(line);
});
reader.on('close', function () {
    let n = parseInt(lines[0])
    let l = lines[1].split(" ").map(v => parseInt(v))

    l.sort((a: number, b: number) => a - b)

    let ans = 0

    for (let i = 0; i < n; i++) {
        for (let j = 0; j < i; j++) {
            for (let k = 0; k < j; k++) {
                if(l[i] != l[j] && l[j] != l[k] && l[k] != l[i]) {
                    if(l[i] + l[j] < l[k]) {
                        ans++
                    }
                }
            }
        }
    }

    console.log(ans)
});


N = int(input())
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(0, N-2):
  for j in range(i+1, N-1):
    for k in range(j+1, N):
      if L[i] == L[j] or L[j] == L[k] or L[i] == L[k]:
        pass
      elif L[i] + L[j] > L[k]:
        ans += 1
      else:
        pass

print(ans)


# compiled by pythran
"""
#pythran export main2()
import numpy as np
i4 = np.int32
i8 = np.int64

def main(in_file):
    stdin = open(in_file)
    N, M, K = [int(x) for x in stdin.readline().split()]
    a = np.array([int(x) for x in stdin.readline().split()])
    b = np.array([int(x) for x in stdin.readline().split()])

    asum = 0
    for i in range(N):
        asum += a[i]
        if asum > K:
            i0 = i
            asum -= a[i]
            break
    else:
        i0 = N

    b_total = K - asum
    j = 0
    bsum = 0
    ans = 0
    for i in range(i0 - 1, -1, -1):
        while True:
            if bsum > b_total:
                ans = max(ans, i + j)
                break
            else:
                if j == M:
                    ans = max(ans, i + j + 1)
                    break
                bsum += b[j]
                j += 1
        if j == M:
            break
        b_total += a[i]
    else:
        while True:
            if bsum > b_total:
                ans = max(ans, j - 1)
                break
            else:
                if j == M:
                    ans = max(ans, j)
                    break
                bsum += b[j]
                j += 1

    print(ans)

def main2():
    main('/dev/stdin')
"""
import os, sys
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
if len(sys.argv) == 1:
    import subprocess
    if p == "":
        pymain = "./" + pymain
    subprocess.call(pymain)
else:
    import gzip, base64, stat
    gz = b'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'
    bin = gzip.decompress(base64.b64decode(gz))
    with open(pymain, "wb") as f:
        f.write(bin)
    os.chmod(pymain, 0o775)