Problem:
Score : 400 points

Problem Statement

We have N balls. The i-th ball has an integer A_i written on it.

For each k=1, 2, ..., N, solve the following problem and print the answer.

Find the number of ways to choose two distinct balls (disregarding order) from the N-1 balls other than the k-th ball so that the integers written on them are equal.

Constraints

3 \leq N \leq 2 \times 10^5

1 \leq A_i \leq N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

For each k=1,2,...,N, print a line containing the answer.

Sample Input 1

5
1 1 2 1 2

Sample Output 1

2
2
3
2
3

Consider the case k=1 for example. The numbers written on the remaining balls are 1,2,1,2.

From these balls, there are two ways to choose two distinct balls so that the integers written on them are equal.

Thus, the answer for k=1 is 2.

Sample Input 2

4
1 2 3 4

Sample Output 2

0
0
0
0

No two balls have equal numbers written on them.

Sample Input 3

5
3 3 3 3 3

Sample Output 3

6
6
6
6
6

Any two balls have equal numbers written on them.

Sample Input 4

8
1 2 1 4 2 1 4 1

Sample Output 4

5
7
5
7
7
5
7
5

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

public class Solve
{
    static void Main(string[] args)
    {
        new ABC_D();
    }
}
public class ABC_A
{
    public ABC_A()
    {
        var inn = Ex.ReadIntArray();
        int n = inn[0];
        int m = inn[1];
        Console.WriteLine(n * (n - 1) / 2 + m * (m - 1) / 2);
    }
}
public class ABC_B
{
    public ABC_B()
    {
        string s = Ex.Read;
        int n = s.Length;
        Console.WriteLine((c1(s, 1, n) && c1(s, 1, (n - 1) / 2) && c1(s, (n + 3) / 2, n)) ? "Yes" : "No");
    }

    bool c1(string s, int ss, int ee)
    {
        int i = 0;
        while ((ss + i - 1) <= (ee / 2))
        {
            if (s[ss + i - 1] != s[ee - i - 1]) return false;
            i++;
        }

        return true;
    }
}
public class ABC_C
{
    public ABC_C()
    {
        string s = Ex.Read;
        ulong l = ulong.Parse(s);
        var d = (l / 3.0);
        Console.WriteLine(d*d*d);
    }
}
public class ABC_D
{
    public ABC_D()
    {
        var n = Ex.ReadInt;
        var inn = Ex.ReadIntArray();
        long[] arr = new long[n + 1];
        foreach (int i in inn)
        {
            arr[i]++;
        }
        ulong all = 0;
        foreach (long i in arr)
        {
            long j = i;
            if (j >= 2)
                all += (ulong)(j * (j - 1) / 2);
        }
        foreach (int i in inn)
        {
            long j = arr[i] - 1;
            if (j >= 2)
                Console.WriteLine(all - (ulong)((j * (j + 1) / 2)-(j * (j - 1) / 2)));
            else if (j == 1)
                Console.WriteLine(all - 1);
            else
                Console.WriteLine(all);
        }
    }
}
public class ABC_E
{
    public ABC_E()
    {

    }
}
public class ABC_F
{
    public ABC_F()
    {

    }
}
public static class Ex
{
    public static string Read { get { return Console.ReadLine().Trim(); } }
    public static int ReadInt { get { return int.Parse(Read); } }
    public static long ReadLong { get { return long.Parse(Read); } }
    public static double ReadDouble { get { return double.Parse(Read); } }
    public static string[] ReadArray() { return Read.Split(' '); }
    public static int[] ReadIntArray() { return Read.Split(' ').Select(s => int.Parse(s)).ToArray(); }
    public static long[] ReadLongArray() { return Read.Split(' ').Select(s => long.Parse(s)).ToArray(); }
    public static string[] ReadArray(long N) { var ret = new string[N]; for (long i = 0; i < N; ++i) ret[i] = Read; return ret; }
    public static int[] ReadIntArray(long N) { var ret = new int[N]; for (long i = 0; i < N; ++i) ret[i] = ReadInt; return ret; }
    public static long[] ReadLongArray(long N) { var ret = new long[N]; for (long i = 0; i < N; ++i) ret[i] = ReadLong; return ret; }
}