output_description: Print the number of ways to choose three of the sticks with different lengths
  that can form a triangle.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      L_1 L_2 \cdots L_N
attempt: # by the authority of GOD     author: manhar singh sachdev #
  
  import os, sys
  from io import BytesIO, IOBase
  
  
  def main():
      n = int(input())
      l = list(map(int, input().split()))
      ans = 0
      for i in range(n):
          for j in range(i + 1, n):
              for k in range(j + 1, n):
                  if l[i] != l[j] and l[k] != l[j] and l[i] != l[k]:
                      if 2 * max(l[i], l[j], l[k]) < l[i] + l[j] + l[k]:
                          ans += 1
      print(ans)
  
  
  # Fast IO Region
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  We have sticks numbered 1, \cdots, N. The length of Stick i (1 \leq i \leq N)
  is L_i.
  
  In how many ways can we choose three of the sticks with different lengths that
  can form a triangle?
  
  That is, find the number of triples of integers (i, j, k) (1 \leq i < j < k
  \leq N) that satisfy both of the following conditions:
  
    * L_i, L_j, and L_k are all different.
    * There exists a triangle whose sides have lengths L_i, L_j, and L_k.
samples: [{"input": "5\n    4 4 9 7 5", "output": "5\n    \n\nThe following five triples (i, j, k) satisfy the conditions: (1, 3, 4), (1, 4,\n5), (2, 3, 4), (2, 4, 5), and (3, 4, 5).\n\n* * *"}, {"input": "6\n    4 5 4 3 3 5", "output": "8\n    \n\nWe have two sticks for each of the lengths 3, 4, and 5. To satisfy the first\ncondition, we have to choose one from each length.\n\nThere is a triangle whose sides have lengths 3, 4, and 5, so we have 2 ^ 3 = 8\ntriples (i, j, k) that satisfy the conditions.\n\n* * *"}, {"input": "10\n    9 4 6 1 9 6 10 6 6 8", "output": "39\n    \n\n* * *"}, {"input": "2\n    1 1", "output": "0\n    \n\nNo triple (i, j, k) satisfies 1 \\leq i < j < k \\leq N, so we should print 0."}]