Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

import bisect
n, m = map(int, input().split())
A = sorted(map(int, input().split()))
BC = [ list(map(int, input().split())) for _ in range(m) ]
for b, c in BC:
  d = bisect.bisect_left(A, c)
  t = min(d, b)
  A = A[t:d] + [c]*t + A[d:]
print(sum(A))

### FIXED CODE ###

from operator import itemgetter
n, m = map(int, input().split())
A = [(1, i) for i in map(int, input().split())]
BC = [ tuple(map(int, input().split())) for _ in range(m) ]
XY = sorted(A + BC, reverse=True, key=itemgetter(1))
c = n
now = 0
ans = 0
while c > 0 and now < n+m:
  x, y = XY[now]
  t = min(c, x)
  ans += y*t
  c -= t
  now += 1
print(ans)
### BUGGY CODE ###

n = int(input())
ls = list(map(int,input().split()))
p = 0
for i in list(set(ls)):
    a = ls.count(i)
    if a > i:
        p += a-i
    elif a < i:
        p += a
print(p)


### FIXED CODE ###

from collections import Counter
n = int(input())
ls = list(map(int,input().split()))
c = Counter(ls)
p = 0
for s,t in c.items():
    if s > t:
        p += t
    elif s < t:
        p += t - s
print(p)
### BUGGY CODE ###

# from math import factorial
from operator import mul
from functools import reduce


def calc_comb(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    n = int(input())
    a = [int(an) for an in input().split()]
    a.sort()
    ans1 = 0
    ans2 = 0
    max_comb = 0
    for i in range(1, n):
        sub_set = set()
        for j in range(i):
            sub = a[i] - a[j]
            if not sub in sub_set:
                sub_set.add(sub)
                # comb = factorial(a[i]) // (factorial(sub) * factorial(a[j]))
                comb = calc_comb(a[i], a[j])
                if comb > max_comb:
                    max_comb = comb
                    ans1 = a[i]
                    ans2 = a[j]
    print(f'{ans1} {ans2}')


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    _ = int(input())
    a = [int(an) for an in input().split()]
    a.sort()
    half_val = -(-a[-1] // 2)
    dist_list = [abs(half_val - an) for an in a[:-1]]
    min_index = dist_list.index(min(dist_list))
    print(f'{a[-1]} {a[min_index]}')


if __name__ == '__main__':
    main()
### BUGGY CODE ###

import itertools
import numpy as np
from scipy.sparse.csgraph import floyd_warshall

N = int(input())

matr = [tuple(map(int, input().split())) for _ in range(N)]
way = floyd_warshall(matr).astype(int)
if np.any(way < matr):
    print(-1)
    exit()

ans = 0
for a, b in itertools.combinations(range(N), 2):
    for c in range(N):
        if c == a or c == b:
            continue
        if matr[a][b] == matr[a][c] + matr[c][b]:
            break
    else:
        ans += matr[a][b]
print(ans)


### FIXED CODE ###

import itertools
import numpy as np
from scipy.sparse.csgraph import floyd_warshall


def main():
    N = int(input())
    matr = np.array([tuple(map(int, input().split())) for _ in range(N)], dtype=np.int64)
    way = floyd_warshall(matr).astype(int)
    if np.any(way < matr):
        print(-1)
        exit()

    ans = 0
    for a, b in itertools.combinations(range(N), 2):
        eq = (matr[a, b] == (matr[a] + matr[:, b]))
        eq[a] = eq[b] = False
        if not np.any(eq):
            ans += matr[a, b]
    print(ans)


if __name__ == "__main__":
    main()
### BUGGY CODE ###

N=int(input())
X=input()
a=int(X,2)

def popcount(x):
  return bin(x).count("1")
p=X.count('1')
pl=a%(p+1)
if popcount(a)!=1:
  mi=a%(p-1)

def f(x):
  if x==0:
    return 1
  else:
    return f(x%popcount(x))+1

for i in range(N):
  if X[i]=='0':
    b=pl
    b+=pow(2,N-i-1,p+1)
    b%=p+1
  else:
    if popcount(a)!=1:
      b=mi
      b-=pow(2,N-i-1,p-1)
      b%=p-1
    else:
      print(0)
      continue
  print(f(b))


### FIXED CODE ###

N=int(input())
X=input()
a=int(X,2)

def popcount(x):
  return bin(x).count("1")
p=X.count('1')

pl=a%(p+1)
if p!=1:
  mi=a%(p-1)

def f(x):
  if x==0:
    return 1
  else:
    return f(x%popcount(x))+1

for i in range(N):
  if X[i]=='0':
    b=pl
    b+=pow(2,N-i-1,p+1)
    b%=p+1
  else:
    if p!=1:
      b=mi
      b-=pow(2,N-i-1,p-1)
      b%=p-1
    else:
      print(0)
      continue
  print(f(b))
### BUGGY CODE ###

import math

n, p = map(int, input().split())
i = 1
while n * math.log(i) <= math.log(p):
    i += 1
for j in reversed(range(i)):
    pn = p
    for k in range(n):
        if (pn / j) % 1 != 0:
            break
        else:
            pn = pn / j
    else:
        print(j)
        break


### FIXED CODE ###

n, p = map(int, input().split())
d = {}
while p % 2 == 0:
    if 2 not in d:
        d[2] = 1
    else:
        d[2] += 1
    p //= 2
f = 3
while f * f <= p:
    if p % f == 0:
        if f not in d:
            d[f] = 1
            p //= f 
        else:
            d[f] += 1
            p //= f
    else:
        f += 2
if p != 1:
    if p not in d:
        d[p] = 1
    else:
        d[p] += 1
d = sorted(d.items(), key=lambda x:x[1], reverse=True)
ans = 1
for k, v in d:
    if v < n:
        break
    else:
        ans *= k ** (v // n)
print(ans)
### BUGGY CODE ###

N, K = map(int, input().split())
P = list(map(int, input().split()))

max_average = 0
point = 0
for i in range(len(P)-K+1):
    check = 0
    for j in range(K):
        check += P[i+j]

    if check > max_average:
        max_average = check
        point = i
        
count = 0
for p in range(point, point+K):
    count += sum(range(1, P[p]+1)) / P[p]

print(count)

### FIXED CODE ###

import sys
input = sys.stdin.readline

def main():
    N, K = map(int, input().split())
    P = list(map(int, input().split()))

    tmp_max = sum(P[:K])
    tmp = sum(P[:K])
    for i in range(N-K):
        tmp += P[i+K]
        tmp -= P[i]

        if tmp > tmp_max:
            tmp_max = tmp

    print((tmp_max + K) / 2)

main()
### BUGGY CODE ###

import itertools
m = input()
exp = "True"
for i in range(input()):
	x,y = map(int,raw_input().split())
	exp += " and N[" + str(x-1) + "] < N[" + str(y-1) + "]"
for N in itertools.permutations(range(m),m):
	if eval(exp):
		ans = sorted([[N[i],i+1] for i in range(m)])
		for n,i in ans:
			print i
		break

### FIXED CODE ###

def solve(a):
	for i in M-set(a):
		if any(x == i and y not in a for x,y in xy): continue
		r = solve([i]+a)
		if r: return r
	return a
m = input()
M = set(range(1,m+1))
xy = [map(int,raw_input().split()) for i in range(input())]
for i in solve([]): print i
### BUGGY CODE ###

# coding: utf-8
# Your code here!
r , g , b , n = map(int,input().split())
ans = 0
R = -(-n//r)
G = -(-n//g)
for i in range(R+1):
    for j in range(G+1):
        if (n-r*i-g*j)/b >=0 and ((n-r*i-g*j)/b).is_integer():
            ans += 1
print(ans)

### FIXED CODE ###

# coding: utf-8
# Your code here!
r , g , b , n = map(int,input().split())
ans = 0
R = -(-n//r)
G = -(-n//g)
for i in range(R+1):
    for j in range(G+1):
        su = n-r*i-g*j
        if n-r*i-g*j < 0:
            break
        else:
            if (su/b).is_integer():
                ans += 1
print(ans)
### BUGGY CODE ###

import numpy as np
import math
n,m = map(int, input().split())
a = np.array(list(map(int, input().split())))
used = 0
zero = np.zeros(a.shape)
while used < m:
  i = a.argmax()
  a[i] = a[i]//2
  used +=1
print(sum(a))

### FIXED CODE ###

import heapq
n,m = map(int, input().split())
a =list(map(lambda x: int(x)*(-1), input().split()))
heapq.heapify(a)

used = 0
for _ in range(m):
  tmp = heapq.heappop(a)
  heapq.heappush(a, -1*(-tmp//2))
print(-sum(a))
### BUGGY CODE ###

import fractions
N, M = map(int, input().split())
S = input()
T = input()

G = N * M // fractions.gcd(N, M)
slist = [i*(G//N) for i in range(N)]
mlist = [i*(G//M) for i in range(M)]
sm = set(slist) & set(mlist)
for i in sm:
    si = slist.index(i)
    mi = mlist.index(i)
    if S[si] != T[mi]:
        print(-1)
        exit()

print(G)

### FIXED CODE ###

import fractions
N, M = map(int, input().split())
S = input()
T = input()

G = N * M // fractions.gcd(N, M)
slist = [i*(G//N) for i in range(N)]
mlist = [i*(G//M) for i in range(M)]
sm = set(slist) & set(mlist)
for i in sm:
    si = slist.index(i)
    mi = mlist.index(i)
    if S[si] != T[mi]:
        print(-1)
        exit()

print(G)
### BUGGY CODE ###

import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**8
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())

    N,M,R = LI()
    r = _LI()
    root = [[] for _ in range(N)]
    for _ in range(M):
        a,b,c = LI()
        root[a-1].append((b-1,c))
        root[b-1].append((a-1,c))

    min_r = INF
    for x in itertools.permutations(r):
        it = 0
        s = x[0]
        for t in x[1:]:
            node = [INF] * N
            q = [(s,0)]
            while q:
                u,l = q.pop()
                node[u] = l
                for v,m in root[u]:
                    if node[v] > l + m:
                        q.append((v,l+m))
            it += node[t]
            s = t
        min_r = min(min_r,it)
    print(min_r)
    
if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**8
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())

    N,M,R = LI()
    r = _LI()
    root = [[] for _ in range(N)]
    for _ in range(M):
        a,b,c = LI()
        root[a-1].append((b-1,c))
        root[b-1].append((a-1,c))

    memo = [[0] * N for _ in range(N)]

    min_r = INF
    for x in itertools.permutations(r):
        it = 0
        s = x[0]
        for t in x[1:]:
            if memo[s][t]:
                it += memo[s][t]
            else:
                node = [INF] * N
                q = collections.deque()
                q.append((s,0))
                node[s] = 0
                while q:
                    u,l = q.popleft()
                    for v,m in root[u]:
                        if node[v] > l + m:
                            node[v] = l + m
                            q.append((v,l+m))
                memo[s][t] = node[t]
                memo[t][s] = node[t]
                it += node[t]
            s = t
        min_r = min(min_r,it)
    print(min_r)

if __name__ == '__main__':
    main()
### BUGGY CODE ###

import sys
sys.setrecursionlimit(10**6)

n, u, v = map(int, input().split())
u, v = u-1, v-1
edges = [[] for i in range(n)]
for i in range(n-1):
    ai, bi = map(int, input().split())
    ai, bi = ai-1, bi-1
    edges[ai].append(bi)
    edges[bi].append(ai)

def dfs(already, node, depth):
    depth += 1
    children = edges[node]
    for child in children:
        if already[child] == 0:
            already[child] = depth
            already = dfs(already, child, depth)
    return already

already_u = [0 for i in range(n)]
already_u[u] = -1
already_u = dfs(already_u, u, 0)
already_u[u] = 0
already_v = [0 for i in range(n)]
already_v[v] = -1
already_v = dfs(already_v, v, 0)
already_v[v] = 0

maxi = 0
for i in range(n):
    if already_u[i] < already_v[i]:
        maxi = max(maxi, already_v[i])
print(maxi-1)

### FIXED CODE ###

n, u, v = map(int, input().split())
u, v = u-1, v-1
edges = [[] for i in range(n)]
for i in range(n-1):
    ai, bi = map(int, input().split())
    ai, bi = ai-1, bi-1
    edges[ai].append(bi)
    edges[bi].append(ai)

depth = 0
already = [0 for i in range(n)]
already[v] = 1
nodes = [v]
while nodes != []:
    depth += 1
    next_nodes = []
    for node in nodes:
        children = edges[node]
        for child in children:
            if already[child] == 0:
                already[child] = depth
                next_nodes.append(child)
    nodes = next_nodes
already[v] = 0

depth = 0
already_u = [0 for i in range(n)]
already_u[u] = 1
nodes = [u]
while nodes != []:
    depth += 1
    next_nodes = []
    for node in nodes:
        children = edges[node]
        for child in children:
            if already_u[child] == 0:
                already_u[child] = depth
                next_nodes.append(child)
    nodes = next_nodes
already_u[u] = 0

maxi = 0
for i in range(n):
    if already_u[i] < already[i]:
        maxi = max(maxi, already[i])

print(maxi-1)
### BUGGY CODE ###

import queue
import sys
sys.setrecursionlimit(5*10**5)

N, Q = map(int, input().split())
ab=[]
for _ in range(N-1):
    ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
    px.append(tuple(map(int, input().split())))

cnt=[0]*(N+1)
for el in px:
    cnt[el[0]]+=el[1]
#print(cnt)

todo=queue.Queue()
seen=[False]*(N+1)

lst=[[] for _ in range(N+1)]
for el in ab:
    lst[el[0]].append(el[1])
    lst[el[1]].append(el[0])
#print(lst)

def bfs(n):
    seen[n]=True
    for child in lst[n]:
        if seen[child]==False:
            cnt[child]+=cnt[n]
            todo.put(child)
    if not todo.empty():
        bfs(todo.get(0))
    else:
        return None

bfs(1)
#print(cnt)
print(' '.join(list(map(str, cnt[1:]))))

### FIXED CODE ###

import sys
sys.setrecursionlimit(5*10**5)
input = sys.stdin.readline

N, Q = map(int, input().split())
ab=[]
for _ in range(N-1):
    ab.append(tuple(map(int, input().split())))
px=[]
for _ in range(Q):
    px.append(tuple(map(int, input().split())))

cnt=[0]*(N+1)
for el in px:
    cnt[el[0]] += el[1]
#print(cnt)


lst=[[] for _ in range(N+1)]
for el in ab:
    lst[el[0]].append(el[1])
    lst[el[1]].append(el[0])
#print(lst)

seen = [False] * (N + 1)
def dfs(n):
    seen[n] = True
    for child in lst[n]:
        if seen[child] == False:
            cnt[child]+=cnt[n]
            dfs(child)

dfs(1)
#print(cnt)
print(' '.join(list(map(str, cnt[1:]))))
### BUGGY CODE ###

# this is a good problem !

import sys
si = sys.stdin.readline

d = ['R', 'G', 'B']
ld = [[], [], []]  # letter distribution


def main():
    count = 0
    n = int(si())
    l = list(si())
    l.pop()
    dc = d[:]

    for i in range(n-1, -1, -1):
        if i == n-1:
            if l[i] == 'R':
                ld[0].append(1)
                ld[1].append(0)
                ld[2].append(0)
            elif l[i] == 'G':
                ld[0].append(0)
                ld[1].append(1)
                ld[2].append(0)
            else:
                ld[0].append(0)
                ld[1].append(0)
                ld[2].append(1)
        else:
            if l[i] == 'R':
                ld[0] = [ld[0][0]+1]+ld[0]
                ld[1] = [ld[1][0]+0]+ld[1]
                ld[2] = [ld[2][0]+0]+ld[2]
            elif l[i] == 'G':
                ld[0] = [ld[0][0]+0]+ld[0]
                ld[1] = [ld[1][0]+1]+ld[1]
                ld[2] = [ld[2][0]+0]+ld[2]
            else:
                ld[0] = [ld[0][0]+0]+ld[0]
                ld[1] = [ld[1][0]+0]+ld[1]
                ld[2] = [ld[2][0]+1]+ld[2]

    for i in range(n-2):
        r1 = l[i]
        dc.remove(r1)
        for j in range(i+1, n-1):
            if l[j] in dc:
                r2 = l[j]
                dc.remove(r2)
                count += ld[d.index(dc[0])][j+1]
                if (j+j-i) < n and l[j+j-i] in dc:
                    count -= 1
                dc += [r2]
        dc += [r1]
    print(count)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
si = sys.stdin.readline
so = sys.stdout.write


def main():
    n = int(si())
    s = si()[:-1]
    cnt = s.count('R')*s.count('G')*s.count('B')

    for i in range(n-2):
        for j in range(i+1, n-1):
            k = j+j-i
            if k < n and s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
                cnt -= 1

    print(cnt)


if __name__ == '__main__':
    main()
### BUGGY CODE ###

import bisect
import sys
sys.setrecursionlimit(3*10**5)

INF = 10**10

N = int(input())
a = list(map(int,input().split()))
T = [set() for x in range(N)]
for i in range(N-1):
    u,v = map(int,input().split())
    u -= 1
    v -= 1
    T[u].add(v)
    T[v].add(u)

search = [0]*N

A = [INF]*N

ans = [-1]*N

def dfs(V,i):
    num = a[V]
    k = bisect.bisect_left(A,num)
    v = A[k]
    A[k] = num
    if v == INF:
        i += 1
    ans[V] = i
    for VV in T[V]:
        if search[VV]:
            continue
        search[VV] = 1
        dfs(VV,i)
    A[k] = v

search[0] = 1
dfs(0,0)

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

### FIXED CODE ###

import bisect
import sys
sys.setrecursionlimit(3*10**5)

INF = 10**10

N = int(input())
a = list(map(int,input().split()))
T = [set() for x in range(N)]
for i in range(N-1):
    u,v = map(int,input().split())
    u -= 1
    v -= 1
    T[u].add(v)
    T[v].add(u)

search = [0]*N

A = [INF]*N

ans = [-1]*N

def dfs(V):
    num = a[V]
    k = bisect.bisect_left(A,num)
    v = A[k]
    A[k] = num
    ans[V] = bisect.bisect_left(A,INF)
    # このにぶたん無駄じゃね？まあ間に合うからいいか……
    for VV in T[V]:
        if search[VV]:
            continue
        search[VV] = 1
        dfs(VV)
    A[k] = v

search[0] = 1
dfs(0)

print(*ans,sep="\n")
### BUGGY CODE ###

n = int(input())
s = 0
while n:
    d = n%10
    n = n//10
    s += d
if s%9 == 0:
    print("Yes")
else:
    print("No")
#a = list(map(int,input().split()))
#n,k,t = map(int,input().split())


### FIXED CODE ###

n = int(input())
if n%9 == 0:
    print("Yes")
else:
    print("No")
### BUGGY CODE ###

import numpy as np

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

a2 = []
for i in range(n):
    a2.append((a[i], i))
a2.sort(reverse=True)

dp = np.full((n, n), -1)
for i2 in range(n-1, -1, -1):
    a, i = a2[i2]

    for s in range(i2+1):
        if i2 == n-1:
            dp[i2][s] = a * abs(s-i)
        else:
            dp[i2][s] = max(dp[i2+1][s+1] + a * abs(s - i),
                            dp[i2+1][s] + a * abs(n-1-i2+s - i))

print(dp[0][0])

### FIXED CODE ###

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

a2 = []
for i in range(n):
    a2.append((a[i], i))
a2.sort(reverse=True)

dp = [[-1] * n for _ in range(n)]
for i2 in range(n-1, -1, -1):
    a, i = a2[i2]

    for s in range(i2+1):
        if i2 == n-1:
            dp[i2][s] = a * abs(s-i)
        else:
            dp[i2][s] = max(dp[i2+1][s+1] + a * abs(s - i),
                            dp[i2+1][s] + a * abs(n-1-i2+s - i))

print(dp[0][0])
### BUGGY CODE ###

from collections import Counter

N = int(input())
dic = {}

for _ in range(N):
    s = sorted(input())
    s = str(s)
    if s in dic.keys():
        dic[s] += 1
    else:
        dic[s] = 1

print(sum(d * (d-1) // 2 for d in dic.values() if d > 1))

### FIXED CODE ###

from collections import Counter

N = int(input())
dic = {}

for _ in range(N):
    s = sorted(input())
    s = str(s)
    if s in dic.keys():
        dic[s] += 1
    else:
        dic[s] = 1

print(sum(d * (d-1) // 2 for d in dic.values() if d > 1))
### BUGGY CODE ###

N = int(input())
ans = 1
for i in range(1,N+1):
    ans *= i
print(ans % (10 ** 9 + 7))

### FIXED CODE ###

N = int(input())

ans = 1
for i in range(1,N+1):
    ans *= i
    ans %= (10 ** 9 + 7)
print(ans)
### BUGGY CODE ###

r, g, b, n = map(int, input().split())
arr = [r, g, b]
arr.sort()
ans = 0
for i in range(n // arr[2] + 1):
    for j in range(n // arr[1] + 1):
        tmp = arr[2] * i + arr[1] * j
        if tmp > n:
            break
        else:
            if tmp == n:
                ans += 1
            elif n - tmp > 0 and (n - tmp) % arr[0] == 0:
                ans += 1

print(ans)


### FIXED CODE ###

R, G, B, n = map(int, input().split())
ans = 0
for r in range(n // R + 1):
    Rr = R * r
    for g in range((n - Rr) // G + 1):
        tmp = Rr + G * g
        if (n - tmp) % B == 0:
            ans += 1
print(ans)
### BUGGY CODE ###

N, M = map(int, input().split())

output = 1
for i in range(M//N, 0, -1):
    if M % i == 0 and output < i:
        output = i
print(output)


### FIXED CODE ###

N, M = map(int, input().split())

output = 1
for i in range(M//N, 0, -1):
    if M % i == 0 and output < i:
        output = i
        break
print(output)
### BUGGY CODE ###

import sys
from collections import deque
input = sys.stdin.readline
N, M = map(int, input().split())
*A, = map(int, input().split())
lis = []
for _ in range(M):
    B, C = map(int, input().split())
    for _ in range(B):
        lis.append(C)
A.sort()
d = deque(A)
lis.sort(reverse=True)
l = len(lis)
for i in range(l):
    if d[0] < lis[i]:
        d.popleft()
        d.append(lis[i])
print(sum(d))


### FIXED CODE ###

import sys
input = sys.stdin.readline
N, M = map(int, input().split())
*A, = map(int, input().split())
dic = {}
for a in A:
    if a in dic:
        dic[a] += 1
    else:
        dic[a] = 1
for _ in range(M):
    B, C = map(int, input().split())
    if C in dic:
        dic[C] += B
    else:
        dic[C] = B
dic = list(map(lambda x: list(x), sorted(dic.items(), reverse=True)))
i = 0
ans = 0
for _ in range(N):
    ans += dic[i][0]
    dic[i][1] -= 1
    if dic[i][1] == 0:
        i += 1
print(ans)
### BUGGY CODE ###

N = int(input())
S = [input() for _ in range(N)]
SS = sorted(list(set(S)))
count = [0]*len(SS)
for i in S:
    count[SS.index(i)] += 1
ans = max(count)
for j in range(len(SS)):
    if count[j] == ans:
        print(SS[j])

### FIXED CODE ###

count = {}
for i in range(int(input())):
    S = input()
    if S in count:
        count[S] += 1
    else:
        count[S] = 1
ans = max(count.values())
print(*sorted([A[0] for A in count.items() if A[1] == ans]))