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 (Python):
n = int(input())
a = list(map(int,input().split()))
raw = [0 for _ in range(3*10**5)]
for x in a:
  raw[x] += 1
ans = 0
for y in raw:
  ans += y * (y-1) // 2
for x in a:
  tmp = int(ans)
  tmp -= raw[x] - 1
  print(tmp)

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

n = onem()
a = l()
dp = [[0,0] for i in range(2*(10**5)+1)]
po = s(sorted(a))

su = 0
for i in range(len(po)):
    dp[po[i][0]] = [po[i][1],po[i][1]*(po[i][1]-1)//2]
    su += dp[po[i][0]][1]



for i in range(n):
    ppp = dp[a[i]][1]
    print(su - ppp + (dp[a[i]][0]-1)*(dp[a[i]][0]-2)//2)

Solution (Python):
N = int(input())
d = {}
for i in range(1,N+1):
    d[i] = 0
A = list(map(int,input().split()))
for i in range(N):
    a = A[i]
    d[a] += 1
s = 0
for i in range(1,N+1):
    x = d[i]
    s += (x*(x-1))//2
for i in range(N):
    y = A[i]
    z = s + 1 - d[y]
    print(z)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
l = [0 for i in range(n+1)]
ans = 0
for i in range(n):
    l[a[i]] += 1
for i in range(n+1):
    ans += (l[i]*(l[i]-1))//2
al = []
for i in range(n):
    a0 = ans - (l[a[i]]*(l[a[i]]-1))//2 + ((l[a[i]]-1)*(l[a[i]]-2)//2)
    al.append(a0)
for i in al:
    print(i)

Solution (Python):
N=int(input())
*A, = map(int,input().split())

C = {}
for a in A:
    C[a] = C.get(a,0) + 1

ans0 = 0
for c in C.values():
    ans0 += c*(c-1)//2

for a in A:
    n = C[a]
    ans = ans0 - n*(n-1)//2 + (n-1)*(n-2)//2
    print(ans)

Solution (Python):
import sys
input = sys.stdin.buffer.readline

from collections import defaultdict

N = int(input())
A = list(map(int, input().split()))

cnt = defaultdict(int)
for a in A:
    cnt[a] += 1

sum_cnt = 0
for a in cnt.values():
    sum_cnt += a * (a - 1) // 2



for a in A:
    cnta = cnt[a]
    print(sum_cnt - cnta * (cnta - 1) // 2 + (cnta - 1) * (cnta - 2) // 2)

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
from operator import mul
from functools import reduce
def cmb(n, r):
  if not n >= r:return 0
  r = min(n-r, r)
  if r == 0:
      return 1
  over = reduce(mul, range(n, n - r, -1))
  under = reduce(mul, range(1, r + 1))
  return over // under


n = int(input())
A = list(map(int,input().split()))
C = collections.Counter(A)
for i in range(n+1):
  ans += cmb(C[i],2)
for i,ai in enumerate(A):
  print(ans-cmb(C[ai],2) + cmb(C[ai]-1,2))

Solution (Python):
n, *a = map(int, open(0).read().split())
x = [0]*n
for i in a: x[i-1] += 1
c = sum([i*(i-1)//2 for i in x])

z = [c - x[i]*(x[i]-1)//2 + (x[i]-1)*(x[i]-2)//2 for i in range(n)]
for i in a: print(z[i-1])

Solution (Python):
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
ac = Counter(a).most_common()
all_sum = sum([x * (x-1) // 2 for _, x in ac])
dic = {i: x for i, x in ac}
for i in range(n):
    print(all_sum - dic[a[i]] + 1)

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    n = inp()
    a = inpl()
    dic = defaultdict(int)
    for i in range(n):
        dic[a[i]] += 1
    ans = 0
    for e in dic:
        num = dic[e]
        ans += (num*(num-1))//2
    for i in range(n):
        print(ans-(dic[a[i]]*(dic[a[i]]-1))//2+((dic[a[i]]-1)*(dic[a[i]]-2))//2)
    
if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
As = [int(s) - 1 for s in input().split()]

Cs = [0 for _ in range(N)]
for A in As:
    Cs[A] += 1

a = [C * (C - 1) // 2 for C in Cs]
b = [(C - 1) * (C - 2) // 2 for C in Cs]

S = sum(a)

for A in As:
    print(S - a[A] + b[A])

Solution (Python):
from collections import  Counter
N = int(input())
A = list(map(int,input().split()))

cnt = Counter(A)

ans = 0
for k,v in cnt.items():
    ans += v*(v-1)//2


for a in A:
    n = cnt[a]
    print(ans - n*(n-1)//2 + (n-1)*(n-2)//2)

Solution (Python):

import sys
from collections import defaultdict
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    N=int(input())
    A=list(map(int,input().split()))
    d=defaultdict(int)
    s=set()
    for x in A:
        d[x]+=1
        s.add(x)
    W=0
    for x in s:
        W+=d[x]*(d[x]-1)//2
    for x in A:
        a=d[x]
        print(W-a*(a-1)//2+(a-1)*(a-2)//2)

if __name__ == '__main__':
    main()

Solution (Python):
from collections import Counter, defaultdict, deque

N, = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]


def choose2(n):
    return (n * (n - 1)) // 2


counts = Counter(A)
total = 0
for x, count in counts.items():
    total += choose2(count)

for x in A:
    old = choose2(counts[x])
    new = choose2(counts[x] - 1)

    print(total - old + new)

Solution (Python):
from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
d = defaultdict(int)
for i in a:
    d[i] += 1
ans = 0
for v in d.values():
    ans += v * (v - 1) // 2
for i in a:
    v = d[i]
    print(ans - v * (v - 1) // 2 + (v - 1) * (v - 2) // 2)

Solution (Python):
from collections import Counter
import sys
input = sys.stdin.readline

def combination(n, k):
    numer = denom = 1
    for i in range(k):
        numer *= n-i
        denom *= i+1
    return numer // denom

N = int(input())
A = list(map(int, input().split()))
counter = Counter(A)
num1 = {}
num2 = {}
total = 0
for k, v in counter.items():
    total += combination(v, 2)
    num1[k] = combination(v, 2)
    num2[k] = combination(v-1, 2)
for a in A:
    print(total - num1[a] + num2[a])

Solution (Python):
from collections import defaultdict
N = int(input())
A = [int(c) for c in input().split()]
dic = defaultdict(list)
for i,a in enumerate(A):
  dic[a].append(i)
s = 0
for k in dic.keys():
  n = len(dic[k])
  s += n*(n-1)//2
for i,a in enumerate(A):
  n = len(dic[a])
  print(s-n+1)

Solution (Python):
import sys
from collections import Counter

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    n=II()
    aa=LI()
    ac=Counter(aa)
    s=sum(c*(c-1)//2 for a,c in ac.items())
    for a in aa:
        c=ac[a]
        print(s-c*(c-1)//2+(c-1)*(c-2)//2)

main()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
memo = {}
for i in range(n):
    if a[i] not in memo:
        memo[a[i]] = 1
    else:
        memo[a[i]] += 1
ans = 0
for i in memo:
    ans += memo[i] * (memo[i] - 1) // 2
    
for i in range(n):
    print(ans - memo[a[i]] * (memo[a[i]] - 1) // 2 + (memo[a[i]] - 1) * (memo[a[i]] - 2) // 2)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt = [0]*(n+1)
for i in range(n):
    cnt[a[i]]+=1
res = 0
for i in range(n+1):
    res+=cnt[i]*(cnt[i]-1)//2
for i in range(n):
    c = cnt[a[i]]
    print(res-c*(c-1)//2+(c-1)*(c-2)//2)

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
n=int(input())
A=[int(i) for i in input().split()]
import collections
D=collections.defaultdict(int)
for a in A:
  D[a]+=1
tot=0
for d in D.keys():
  if D[d]>=2:
    tot+=D[d]*(D[d]-1)//2
for a in A:
  ans=tot-D[a]*(D[a]-1)//2+(D[a]-1)*(D[a]-2)//2
  print(ans)

Solution (Python):
n = int(input())
al = list(map(int,input().split()))

from collections import defaultdict
dic = defaultdict(int)

for a in al:
    dic[a] += 1

sum_d = 0
for a in dic:
    sum_d += dic[a] * (dic[a] - 1) // 2

for a in al:
    k = dic[a] * (dic[a] - 1) // 2
    l = (dic[a] - 2) * (dic[a] - 1) // 2
    print(sum_d - k + l)

Solution (Python):
from collections import Counter

N = int(input())
A = [int(i) for i in input().split()]

cnt = Counter(A)
mem = dict()
for k, v in cnt.items() :
  mem[k] = v * (v - 1) // 2

s = sum(mem.values())
for i in range(N) :
  ret = s - mem[A[i]] + (cnt[A[i]] - 1) * (cnt[A[i]] - 2) // 2
  print(ret)

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



N = I()
A = LI()

d = defaultdict(int)
for i in range(N):
    d[A[i]] += 1

s = 0
for k in d.keys():
    s += d[k]*(d[k]-1)//2

for i in range(N):
    print(s-(d[A[i]]-1))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

from collections import defaultdict

d = defaultdict(lambda:0)
for i in range(N):
    d[A[i]] += 1

ans = 0
for k in d:
    ans += d[k]*(d[k]-1)//2

for i in range(N):
    print(ans-d[A[i]]+1)

Solution (Python):
import os
import sys
from collections import Counter

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


N = int(sys.stdin.buffer.readline())
A = list(map(int, sys.stdin.buffer.readline().split()))

counter = Counter(A)
counts = [0] * (max(A) + 1)
for k, cnt in counter.items():
    if cnt >= 2:
        counts[k] = (cnt - 1) * cnt // 2

s = sum(counts)
ans = []
for a in A:
    cnt = counter[a] - 1
    if cnt >= 2:
        a = s - counts[a] + (cnt - 1) * cnt // 2
    else:
        a = s - counts[a]
    ans.append(a)

print(*ans, sep='\n')

Solution (Python):
from collections import Counter

N = int(input())
A = list(map(int,input().split()))

cnt = Counter(A)

s = sum(c*(c-1)//2 for c in cnt.values())

for a in A:
    c = cnt[a]
    print(s-(c-1)*c//2 + (c-2)*(c-1)//2)

Solution (Python):
from collections import Counter

n = int(input())
a = list(map(int, input().split()))

c = Counter(a)
sm = 0
for v in c.values():
    sm += v * (v - 1) // 2

for e in a:
    v = c[e]
    ans = sm - v * (v - 1) // 2 + (v - 1) * (v - 2) // 2
    print(ans)

Solution (Python):
N = input()
A = [int(x)-1 for x in raw_input().split()]

C = [0]*N
for a in A:
  C[a] += 1
s = sum(c*(c-1)/2 for c in C)
for a in A:
  print s-C[a]+1

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

N += 1
L = [0] * N 

for i in A:
  L[i] += 1

Ans = 0
for i in range(N):
  t = L[i]
  Ans += (t * (t - 1)) // 2

for i in A:
  t = L[i]
  k = (t * (t - 1)) // 2
  t -= 1
  k -= (t * (t - 1)) // 2
  print(Ans - k)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
from collections import defaultdict
d=defaultdict(int)
for i in a:d[i]+=1
ans=0
for i in d:ans+=d[i]*(d[i]-1)//2
for i in a:
  x=d[i]*(d[i]-1)//2
  y=(d[i]-1)*(d[i]-2)//2
  print(ans-x+y)

Solution (Python):

N = int(input())

A = list(map(int,input().split()))

dic = {}

asum = 0

for i in A:
    if i not in dic:
        dic[i] = 1
    else:
        dic[i] += 1

for i in dic:

    asum += dic[i] * (dic[i]-1) // 2

for i in A:

    print (asum - (dic[i] * (dic[i]-1) // 2) + ((dic[i]-1)*(dic[i]-2)//2) )

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

from collections import Counter
c = Counter(a)

tmp = []
for key in c.keys():
    tmp.append(c[key] * (c[key] - 1) // 2)

tmpsum = sum(tmp)

for k in a:
    print(tmpsum - c[k] * (c[k] - 1) // 2 + (c[k] - 1) * (c[k] - 2) // 2)

Solution (Python):
from collections import Counter

n = int(input())
A = list(map(int, input().split()))
C = Counter(A)
cnt = 0
for v in C.values():
  cnt += v*(v-1)//2
for a in A:
  q = C[a]
  ans = cnt - q*(q-1)//2 + (q-1)*(q-2)//2
  print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

ball = [0]*200001
for i in range(n):
    ball[a[i]] += 1

ans = 0
for i in range(1, 200001):
    ans += ball[i]*(ball[i]-1)//2

for i in range(n):
    now = a[i]
    ans -= ball[now]*(ball[now]-1)//2
    ans += (ball[now]-1)*(ball[now]-2)//2
    print(ans)
    ans += ball[now]*(ball[now]-1)//2
    ans -= (ball[now]-1)*(ball[now]-2)//2

Solution (Python):
import sys
input = sys.stdin.readline

from collections import Counter

N = int(input())
A = list(map(int, input().split()))

C = Counter(A)

ans = 0
for v in C.values():
    ans += v*(v-1)//2

for a in A:
    v = C[a]
    if v == 1:
        print(ans)
    else:
        print(ans - v*(v-1)//2 + (v-1)*(v-2)//2)

Solution (Python):
from collections import Counter

n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
base = 0
for i in c.values():
    base += i*(i-1)//2

ans = []
for ai in a:
    k = c[ai]
    tmp = base - k*(k-1)//2 + (k-1)*(k-2)//2
    ans.append(tmp)

print(*ans, sep="\n")

Solution (Python):
import numpy as np


def main():
    N = int(input())
    A = [int(x) for x in input().split()]

    from collections import Counter

    c = Counter(A)

    num = {x: n*(n-1)//2 for x, n in c.items()}
    tot = sum(num.values())

    for x in A:
        n = c[x] - 1
        ans = tot - num[x] + n*(n-1)//2
        print(ans)


if __name__ == '__main__':
    main()

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read


n,*a = [int(i) for i in read().split()]

from collections import Counter
c = Counter(a)
res = sum(v*(v-1)//2 for k,v in c.items())

for i in a:
    v = c[i]
    ans = res - v*(v-1)//2 + (v-1)*(v-2)//2
    print(ans)

Solution (Python):
import sys
from collections import defaultdict

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n = ni()
a = na()

nums = defaultdict(int)
ans = 0
for v in a:
    ans += nums[v]
    nums[v] += 1

for v in a:
    print(ans - (nums[v]-1))

Solution (Python):
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
ans = sum([v * (v-1)//2 for v in c.values()])
for x in a:
	print(ans - c[x] + 1)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
data = [0 for _ in range(2*10**5+1)]
for x in a:
    data[x] += 1

ans = 0
for i in range(2*10**5):
    ans += data[i]*(data[i]-1)//2

for x in a:
    print(ans - (data[x]-1))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]

b = {}
for i in a:
    if i in b:
        b[i] += 1
    else:
        b[i] = 1

c = 0
for i in b:
    c += b[i] * (b[i] - 1) // 2

for i in a:
    print(c-b[i]+1)

Solution (Python):
N = int(input())
A = [int(a)-1 for a in input().split()]
X = [0] * N
for a in A:
    X[a] += 1
s = 0
for x in X:
    s += x * (x-1) // 2

for a in A:
    print(s - (X[a] - 1))

Solution (Python):
from collections import Counter
def main():
    N,*A=map(int, open(0).read().split())
    C=Counter(A)
    x=0
    for v in C.values():
        x+=v*(v-1)//2
    for a in A:
        print(x-(C[a]-1))

if __name__ == "__main__":
    main()

Solution (Python):
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
c = Counter(a)
ans = 0
for x in c.values():
  ans += x*(x-1)//2
for i in range(n):
  t = c[a[i]]
  print(ans-t+1)

Solution (Python):
N, = map(int, input().split())
X = list(map(int, input().split()))
from collections import defaultdict
d = defaultdict(int)
for i in range(N):
    d[X[i]] += 1

r = 0
for k in d:
    x = d[k]
    r += x*(x-1)//2

for i in range(N):
    x = d[X[i]]
    print(r - (x*(x-1)//2) + (x-1)*(x-2)//2)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10


def solve():
    n = II()
    a = LI()
    d = defaultdict(int)
    for ai in a:
        d[ai] += 1
    ans = 0
    for key, value in d.items():
        ans += value * (value - 1) // 2
    for i in range(n):
        print(ans - d[a[i]] * (d[a[i]] - 1) // 2 + (d[a[i]] - 2) * (d[a[i]] - 1) // 2)
    return



if __name__ == '__main__':
    solve()

Solution (Python):
N=int(input())
A=list(map(int,input().split()))

from collections import Counter
C=Counter(A)
ANS=0
for i in C.values():
    ANS+=i*(i-1)//2

for a in A:
    k=C[a]

    print(ANS-(k*(k-1)//2)+((k-1)*(k-2)//2))

Solution (Python):
from collections import defaultdict, deque
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7


def inp(): return int(sys.stdin.readline())


def inpl(): return list(map(int, sys.stdin.readline().split()))


def inpl_str(): return list(sys.stdin.readline().split())


N = inp()
aa = inpl()

cnts = [0]*(N+10)

for a in aa:
    cnts[a] += 1

S = 0
for a in aa:
    S += cnts[a]-1

S //= 2

for a in aa:
    print(S - cnts[a] + 1)

Solution (Python):
N=int(input())
A=list(map(int,input().split()))

from collections import Counter
C=Counter(A)
ANS=0
for i in C.values():
    ANS+=i*(i-1)//2

for a in A:
    k=C[a]

    print(ANS-(k*(k-1)//2)+((k-1)*(k-2)//2))