Harryxun/stf_run huggingface dataset:
a = int(input())
num_list = list(map(int,input().split()))
flag = ""
for i in range(a-1):
  if num_list[i]-1 <= num_list[i+1]:
    flag = "ok"
  else:
    flag = "ng"
if flag = "ok":
  print("Yes")
else:
  print("No")


### FIXED CODE ###

from collections import Counter
a = int(input())
num_list = list(map(int,input().split()))
flag = "ok"
num_o = 0
for i in range(a-1):
  if num_list[i] > num_o:
    num_list[i] = num_list[i]-1
    num_o = num_list[i]
  if num_list[i]-num_list[i+1] > 0:
    flag = "ng"
    break

num_counter = Counter(num_list)
num_most = num_counter.most_common()
#if a == num_most[0][1] and a != 0:
#  flag = "No"
if flag == "ok":
  print("Yes")
else:
  print("No")
n, a = map(int, input().split())

r = n % 500
if r > a:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

N = int(input())
A = int(input())

r = N % 500
if r > A:
    print("No")
else:
    print("Yes")
def solv(n, m, a, s):
    a = sorted(a)
    s = sorted(s, key=lambda x: -x[1])
    i = 0
    for (b, c) in s:
        for _ in range(b):
            if c <= a[i]:
                return sum(a)
            elif i >= n:
                return sum(a)
            a[i] = c
            i += 1
    return sum(a)
 
 
if __name__ == '__main__':
 
    n, m = map(int, input().split())
    a = map(int, input().split())
    s = []
    for _ in range(m):
        b, c = map(int, input().split())
        s.append((b, c))
 
    ans = solv(n, m, a, s)
 
    print(ans)

### FIXED CODE ###

#!/usr/bin/env python3


def solv(n, m, a, s):
    a = sorted(a)
    s = sorted(s, key=lambda x: -x[1])
    i = 0
    sum0 = 0
    for (b, c) in s:
        if (i+b) < n and a[i+b] < c:
            sum0 += b*c
            i += b
        else:
            for _ in range(b):
                if i >= n:
                    return sum0
                elif c <= a[i]:
                    return sum0 + sum(a[i:])
                sum0 += c
                i += 1
    if i >= n:
        return sum0
    return sum0 + sum(a[i:])


if __name__ == '__main__':

    n, m = map(int, input().split())
    a = map(int, input().split())
    s = []
    for _ in range(m):
        b, c = map(int, input().split())
        s.append((b, c))

    ans = solv(n, m, a, s)

    print(ans)
s = input()
t = input()

length = min(len(s),len(t))

sorted_s = sorted(s)
soreted_t = sorted(t)[::-1]

for i in range(length):
  if sorted_s[i] == sorted_t[i]:
    pass
  elif sorted_s[i] < sorted_t[i]:
    print('Yes')
    break
  else:
    print('No')
    break

if len(s) < len(t):
  print('Yse')
else:
  print('No')

### FIXED CODE ###

s = input()
t = input()

length = min(len(s),len(t))

sorted_s = sorted(s)
sorted_t = sorted(t)[::-1]

flag = True
for i in range(length):
  if sorted_s[i] == sorted_t[i]:
    pass
  elif sorted_s[i] < sorted_t[i]:
    print('Yes')
    flag = False
    break
  else:
    print('No')
    flag = False
    break

if flag:
  if len(s) < len(t):
    print('Yes')
  else:
    print('No')
X, A = map(int,input().split())
if A//X ==0:
    print(0)
else: print(10)

### FIXED CODE ###

X, A = map(int,input().split())
print(int(X>=A)*10)
import copy
N,M = map(int,input().split())
A = [int(i) for i in input().split()]
A.sort()
A_copy = copy.deepcopy(A)
CB = []
for i in range(M):
    b,c = map(int,input().split())
    CB.append([c,b])
CB.sort(reverse = True)
tmp = 0
for c,b in CB:
    for i in range(b):
        if A_copy[tmp+i]<=c:
            A[tmp+i] = c
        else:
            print(sum(A))
            exit()
    tmp += b

### FIXED CODE ###

import copy
N,M = map(int,input().split())
A = [int(i) for i in input().split()]
A.sort()
A_copy = copy.deepcopy(A)
CB = []
for i in range(M):
    b,c = map(int,input().split())
    CB.append([c,b])
CB.sort(reverse = True)
tmp = 0
for c,b in CB:
    for i in range(b):
        if tmp+i >= N:
            print(sum(A))
            exit()
            
        if A_copy[tmp+i]<c:
            A[tmp+i] = c
        else:
            break
    tmp += b
print(sum(A))
N=int(input)
if N == 1:
  print("Hello World")
else:
  print(str(int(input()) + int(input()))

### FIXED CODE ###

N=int(input())
if N == 1:
  print("Hello World")
else:
  print(str(int(input()) + int(input())))
NMXY = list(map(int,input().split()))
N=NMXY[0]
M=NMXY[1]
X=NMXY[2]
Y=NMXY[3]
x=list(map(int,input().split()))
y=list(map(int,input().split()))
flag1=[]
flag2=[]

Z=list(range(X+1,Y))

for k in Z:
    flag1.append(all([i<k for i in x]))
    flag2.append(all([j>=k for j in y]))
print(flag1)
print(flag2)
if any(flag1) and any(flag2):
    print('No War')
else:
    print('War')


### FIXED CODE ###

a = list(map(int,input().split()))
a.sort()
print(10*a[2]+a[0]+a[1])
x,a = map(int,input().split())

if x < a:
    ans = 0
else;
    ans = 10

print(ans)

### FIXED CODE ###

x,a = map(int,input().split())

if x < a:
    ans = 0
else:
    ans = 10

print(ans)
import numpy as np

a = int(input())
b = np.array([int(x) for x in input().split()])

if(a!=len(b)):
	print('the array size is different')
else:
	c = b%2
	d = b/2
	while sum(c)==0:
		COUNTS = int(1)
		COUNTS += 1
		c = d%2
		d = d/2

print(COUNTS)




### FIXED CODE ###

import numpy as np

a = int(input())
b = np.array([int(x) for x in input().split()])

if(a!=len(b)):
	print('the array size is different')
else:
	c = b%2
	d = b/2
	count = 0
	while sum(c)==0:
		count += 1
		c = d%2
		d = d/2
	print(count)
import numpy as np
 
N, W = map(int, input().split())
 
dp = np.zeros((N+1, W+1), dtype='uint64')
 
for i in range(N):
  w, v = map(int, input().split()) 
  dp[i+1][:w] = dp[i][:w]
  dp[i+1][w:] = np.maximum(dp[i][w:], dp[i][:-w]+v)
print(np.max(dp[N]))

### FIXED CODE ###

N, W = map(int, input().split())
ws = [0]*N
vs = [0]*N

for i in range(N):
  w, v = map(int, input().split())
  ws[i] = w
  vs[i] = v

V = N*(10**3)+1
dp = [[float('inf')]*V for _ in range(N+1)]
# dp[i][j]: i個の品物までを見てjの価値を実現する最小のw
dp[0][0] = 0
temp = 0

for i in range(N):
  w = ws[i]
  v = vs[i]
  for k in range(V):
    if k-v>=0:
      dp[i+1][k] = min(dp[i][k-v]+w, dp[i+1][k])
    dp[i+1][k] = min(dp[i][k], dp[i+1][k])

for j in range(V-1, -1, -1):
  if dp[N][j] <= W:
    print(j)
    exit()
a=[]
for i in range(4):
 a.append(int(input())
print(min(a[0],a[1])+min(a[2],a[3]))

### FIXED CODE ###

a=[]
for i in range(4):
 a.append(int(input()))
print(min(a[0],a[1])+min(a[2],a[3]))
n,q = map(int,input().split())

g = [[] for _ in range(n)]
c = [0] * n
visited = [False] * n

#根に近い順に累積和
def dfs(i):
    visited[i] = True
    for j in g[i]:
        if visited[j] == True:
            continue
        c[j]+=c[i]
        dfs(j)

for i in range(n - 1):
    a,b = map(int,input().split())
    a-=1
    b-=1
    g[a].append(b)
    g[b].append(a)

for i in range(q):
    p,x = map(int,input().split())
    c[p - 1]+=x

dfs(0)

c=[str(i) for i in c]
print(' '.join(c))

### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n,q = map(int,input().split())

g = [[] for _ in range(n)]
c = [0] * n
visited = [False] * n

#根に近い順に累積和
def dfs(i):
    visited[i] = True
    for j in g[i]:
        if visited[j] == True:
            continue
        c[j]+=c[i]
        dfs(j)

for i in range(n - 1):
    a,b = map(int,input().split())
    a-=1
    b-=1
    g[a].append(b)
    g[b].append(a)

for i in range(q):
    p,x = map(int,input().split())
    c[p - 1]+=x

dfs(0)
print(*c)
import numpy as np
numbers = input().split()
x = input().split()
y = input().split()
z = input().split()

k = int(numbers[3])
x.sort(reverse=True)
y.sort(reverse=True)
z.sort(reverse=True)

answer = []
for i in x:
    for j in y:
        price = int(i)+int(j)
        answer.append(price)
del answer[k::]
for m in range(k):
    answer[m] = answer[m] + z[m]

"""
answer.sort(reverse=True)
del answer[k::]
"""
for l in answer:
    print(l)


### FIXED CODE ###

numbers = input().split()
x = input().split()
y = input().split()
z = input().split()

k = int(numbers[3])

answer = []
for i in x:
    for j in y:
        price = int(i)+int(j)
        answer.append(price)
answer.sort(reverse=True)
del answer[k::]
f_ans = []
for m in answer:
    for n in z:
        price = m + int(n)
        f_ans.append(price)

f_ans.sort(reverse=True)
del f_ans[k::]

for l in f_ans:
    print(l)
import numpy as np

num, k = map(int,input().split())

count = 0.

for i in range(1,num+1):
    if i <= k-1:
        times = np.log2(10/i)
        times = int(times) +1
        count += (1/num) * (1/2)**times
    elif i >= k:
        count += 1/num
print(count)



### FIXED CODE ###

import numpy as np

num, k = map(int,input().split())

count = 0.

for i in range(1,num+1):
    if i <= k-1:
        times = np.log2(k/i)
        if times != int(times):
            times = int(times) +1
        else:
            times = int(times)
        count += (1/num) * (1/2)**times
    elif i >= k:
        count += 1/num
print(count)
n = int(input)
lis = [input() for i in range(n)]
print(len(set(lis)))


### FIXED CODE ###

n = int(input())
lis = [input() for i in range(n)]
print(len(set(lis)))
while True:
        a,op,b=map(input().split())
        a=int(a)
        b=int(b)
        op=str(op        
        if op=("+"):
                print(a+b)
        elif op=("-"):
                print(a-b)
        elif op=("*"):
                print(a*b)
        elif op=("/"):
                print(a/b)
        elif op=("?"):
                break



### FIXED CODE ###



while 1:
     s=input()
     if '?' in s: break
     print(int(eval(s)))
a, b = list(map(int,input().split()))
S = list(str(input()))
S[a+1] = str.lower(S[a+1])
S = "".join(map(str,S))
print(S)

### FIXED CODE ###

a, b = list(map(int,input().split()))
S = list(str(input()))
S[b-1] = str.lower(S[b-1])
S = "".join(map(str,S))
print(S)
s = input()
x, y = map(int, input().split())

mv = [len(e) for e in s.split("T")]
mv_x = mv[2::2]
mv_y = mv[1::2]


def solve_dp(li, start, end):
    l = len(li)
    mx = sum(li)
    
    if end > start + mx or end < start - mx:
        return 0

    dp = [[0] * (2 * mx + 1) for _ in range(l + 1)]
    dp[0][start] = 1
    for i, e in enumerate(li, 1):
        for j in range(-mx + start, mx + start + 1):
            if -mx <= j - e <= mx:
                dp[i][j] |= dp[i-1][j-e]
            if -mx <= j + e <= mx:
                dp[i][j] |= dp[i-1][j+e]

    return dp[l][end]


bl_x = solve_dp(mv_x, mv[0], x)
bl_y = solve_dp(mv_y, 0, y)

if bl_x and bl_y:
    ans = "Yes"
else:
    ans = "No"

print(ans)


### FIXED CODE ###

s = input()
x, y = map(int, input().split())

mv = [len(e) for e in s.split("T")]
mv_x = mv[2::2]
mv_y = mv[1::2]


def solve_dp(li, start, end):
    l = len(li)
    mx = sum(li)

    if l == 0:
        return start == end

    left = start - mx
    right = start + mx

    if end > right or end < left:
        return 0

    dp = [[0] * (2 * mx + 1) for _ in range(l + 1)]
    dp[0][start] = 1
    for i, e in enumerate(li, 1):
        for j in range(left, right + 1):
            if left <= j - e <= right:
                dp[i][j] |= dp[i-1][j-e]
            if left <= j + e <= right:
                dp[i][j] |= dp[i-1][j+e]

    return dp[l][end]


bl_x = solve_dp(mv_x, mv[0], x)
bl_y = solve_dp(mv_y, 0, y)

if bl_x and bl_y:
    ans = "Yes"
else:
    ans = "No"

print(ans)
a, b, k = list(map(int, input().split()))
a_ans = a - min(a, k)
if a_ans == 0:
    b_ans = b - min(b, k - a)
print('{} {}'.format(a_ans, b_ans))


### FIXED CODE ###

a, b, k = list(map(int, input().split()))
a_ans = a - min(a, k)
if a_ans == 0:
    b_ans = b - min(b, k - a)
else:
    b_ans = b
print('{} {}'.format(a_ans, b_ans))
a = int(input())
b = int(input())
print(a*b)

### FIXED CODE ###

a, b = list(map(int, input().split()))
print(a*b)
S = input()
T = input()
A = int(input())
B = int(input())
U = input()

if U == T:
    B -= 1
if U == S:
    A -= 1
    
print(str(A) +  " " + str(B))


### FIXED CODE ###

S,T = input().split()
A,B = input().split()
U = input()
A,B = int(A), int(B)

if U == T:
    B -= 1
elif U == S:
    A -= 1

print(A , " " , B)
import numpy as np
k = int(input().split(" ")[-1])

a_ = np.array([int(i) for i in input().split(" ")])
b_ = np.array([int(i) for i in input().split(" ")])
c_ = np.array([int(i) for i in input().split(" ")])

res = np.array([], dtype="int32")
for a in a_:
    for b in b_:
        for c in c_:
            if len(res) == k:
                i = np.argmin(res)
                res[i] = np.max(res[i], a+b+c)
            else:
                res = np.append(res,a+b+c)

res = np.sort(res)[::-1]

for i in range(k):
    print(res[i])

### FIXED CODE ###

x,y,z,K = (int(i) for i in input().split(" "))

a_ = sorted([int(i) for i in input().split(" ")])[::-1]
b_ = sorted([int(i) for i in input().split(" ")])[::-1]
c_ = sorted([int(i) for i in input().split(" ")])[::-1]

res = []
for i in range(x):
    for j in range(y):
        for k in range(z):
            if (i+1)*(j+1)*(k+1) <= K:
                res.append(a_[i]+b_[j]+c_[k])
            else:
                break

res = sorted(res)[::-1]

for i in range(K):
    print(res[i])
import sys
N, M = map(int, input().split())
X = sorted(list(map(int, input().split())))

if M == 1:
  print (0)
  sys.exit()
Y = []
for i in range(M-1):
  Y.append(X[i+1]-X[i])
Y = sorted(Y)
for i in range(N-1):
  Y.pop()
print (sum(Y))


### FIXED CODE ###

import sys
N, M = map(int, input().split())
X = sorted(list(map(int, input().split())))

if M == 1:
  print (0)
  sys.exit()
Y = []
for i in range(M-1):
  Y.append(X[i+1]-X[i])
Y = sorted(Y)
for i in range(N-1):
  if len(Y) == 0:
    print (0)
    sys.exit()
  Y.pop()
print (sum(Y))
q=input()
x=[int(i) for i in input().split()]
cnt=input()
j=0
y=[int(i) for i in input().split()]

if max(x) >= max(y): MAX=max(x)
else : MAX=max(y)

z=[0]*(MAX+1)

for k in x :
    z[k] += 1
    
for i in y :
    z[i] -= 1
    if z[i] == -1 :
        print('NO')
        exit()
        
print('YES')


### FIXED CODE ###


q=input()
x=[int(i) for i in input().split()]
cnt=input()
y=[int(i) for i in input().split()]

if max(x) >= max(y):
    MAX=max(x)
else:
    MAX=max(y)

dic = {}

for k in x :
    if k in dic.keys() :
        dic[k] += 1
    else :
        dic[k] = 1
    
for i in y :
    if i in dic.keys() :
        dic[i] -= 1
        if dic[i] == -1 :
            print('NO')
            exit()
    else :
        print('NO')
        exit()
print('YES')
from collections import deque
h,w,k = map(int,input().split())
a,b,c,d = map(int,input().split())
a -= 1
b -= 1
c -= 1
d -= 1
maze = [input() for _ in range(h)]
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
depth = [[float("inf") for _ in range(w)] for _ in range(h)]
dq = deque([(b,a)])
depth[a][b] = 0
while dq:
    x,y ==dq.popleft()
    if x == d and y == c:
        break
    for i in range(4):
        nx,ny,K = x,y,k
        while K:
            K -= 1
            nx += dx[i]
            ny += dy[i]
        if 0<=nx<=w-1 and 0<=ny<=h-1 and maze[nx][ny] != "@" and depth[nx][ny] > depth[y][x]:
            if depth[ny][nx] == depth[y][x]+1:
                continue
            depth[ny][nx] = depth[y][x] +1
            dq.append((nx,ny))
        else:
            break
print(depth[c][d] if depth[c][d] != float("inf") else -1)




### FIXED CODE ###

from collections import deque
h,w,k = map(int,input().split())
a,b,c,d = map(int,input().split())
a -= 1
b -= 1
c -= 1
d -= 1
maze = [input() for _ in range(h)]
dx = [1,-1,0,0]
dy = [0,0,1,-1]
depth = [[float("inf") for _ in range(w)] for _ in range(h)]
dq = deque([(b,a)])
depth[a][b] = 0
while dq:
    x,y = dq.popleft()
    if x == d and y == c:
        break
    for i in range(4):
        nx,ny,K = x,y,k
        while K:
            K -= 1
            nx += dx[i]
            ny += dy[i]
            if 0<=nx<=w-1 and 0<=ny<=h-1 and maze[ny][nx] != "@" and depth[ny][nx] > depth[y][x]:
                if depth[ny][nx] == depth[y][x]+1:
                    continue
                depth[ny][nx] = depth[y][x] +1
                dq.append((nx,ny))
            else:
                break
print(depth[c][d] if depth[c][d] != float("inf") else -1)
A, B, X = map(int, input().split())

low = 0
high = 10 ** 10

for i in range(10 ** 9):

    if high - low == 1:
        if A * high + B * len(str(high)) <= X:
            print(high)
            break
        else:
            print(low)
            break

    if (high - low) % 2 == 0:
        N = (high - low) // 2 + low
        tmp = A * N + B * len(str(N))

        if tmp < X:
            low = N
        elif tmp > X:
            high = N
        elif tmp == X:
            print(N)
            break

    else:
        N = (high - low) / 2 + low
        floor = int(N)
        ceil = floor + 1

        tmp_floor = A * floor + B * len(str(floor))
        tmp_ceil = A * ceil + B * len(str(ceil))

        if tmp_floor < tmp_ceil < X:
            low = ceil
        elif X < tmp_floor < tmp_ceil:
            high = floor
        elif tmp_floor < X < tmp_ceil:
            low = floor
            high = ceil
        elif X == tmp_floor:
            print(N)
            break
        elif X == tmp_ceil:
            print(N)
            break



### FIXED CODE ###

S = str(input())

x = 0

if S == "MON":
    x += 6
elif S == "TUE":
    x += 5
elif S == "WED":
    x += 4
elif S == "THU":
    x += 3
elif S == "FRI":
    x += 2
elif S == "SAT":
    x += 1
elif S == "SUN":
    x += 7

print(x)
# coding: utf-8

def main():
    N = int(input())
    btc_to_jpy = 380000.0
    ans = 0
    for i in range(N):
        temp_value,unit = input().split()
        value = int(temp_value)
        if unit == "BTC":
            value *= btc_to_jpy
        ans += value
    print(ans)

if __name__ == "__main__":
    main()

### FIXED CODE ###

# coding: utf-8

def main():
    N = int(input())
    btc_to_jpy = 380000.0
    ans = 0
    for i in range(N):
        temp_value,unit = input().split()
        value = float(temp_value)
        if unit == "BTC":
            value *= btc_to_jpy
        ans += value
    print(ans)

if __name__ == "__main__":
    main()
import decimal
import math

N, K = map(int, input().split())
coin = [decimal.Decimal('0.5')**k for k in range(10**3)]
ans = 0

for i in range(1,N+1):
    tmp = decimal.Decimal(str(math.log2(K/i)))
    x = int(math.log2(K/i))
    if i >= K:
        ans += decimal.Decimal(1/N)
    else:
        if tmp - x != 0:
            x += 1
        ans += decimal.Decimal(1/N) * coin[x]

print(ans)


### FIXED CODE ###

import math
N,K = map(int,input().split())
ans = 0
 
for i in range(1,N+1):
    if i >= K:
        ans += (1/N)
        continue
    X = int(math.log((K/i), 2))
    if (K/i) % 2**X == 0:
        pass
    else:
        X += 1
    ans += (1/N) * (1/2) ** X
print(ans)
N = int(input())
ans = 10**10 #適当に初期化
ans_ = 10**10

divisors = []
for i in range(1, int(N**0.5)+1):
    if N % i == 0:
        divisors.append(i)
        if i != N // i:
            divisors.append(N//i)
            if len(str(N//i))<=ans:
                ans =N//i
                ans_=i
            
if N ==1:
    ans =1
            
print(max(len(str(ans)),len(str(ans_))))

### FIXED CODE ###

A,B=map(int,input().split())
time=A+B
if time>=24:
    print (time-24)
else:
    print (time)
H, W = map(int, input().split())

# num = H * W


if H == 0 or W == 0:
    print(int(0))

elif H == 1 or W == 1:
    print(int(1))

elif H % 2 == 0 and W % 2 == 0:
    print(int(H/2 * W))

elif H % 2 == 0:
    print(int(H/2 * W))

elif W % 2 == 0:
    print(int(W/2) * H)

elif H % 2 != 0 and W % 2 != 0:
    key = W // 2
    ans = H * key
    print(int(ans + (H-H//2)))
    # else:
    #     num = H // 2
    #     ans = num * W
    #     print(int(ans + (H-(num))))


### FIXED CODE ###

a, b, c = map(int, input().split())


d = c - a - b

if d > 0 and d ** 2 > 4 * a * b:
    print("Yes")
else:
    print("No")
# -*- coding: utf-8 -*-

# 入力された文字列
string = input()

# 最大処理数。100000以下なら文字列長。
max = min(len(string), 100000)

# 削除した文字数
del_count = 0

# 削除する文字がなくなるまで処理を続ける
del_flg = True

while del_flg:
    del_flg = False
    for idx in range(max):
        target = string[idx : idx + 2]
        if target == "01" or target == "10":
            string_head = string[:idx]
            string_tail = string[idx + 2:]
            string = string_head + string_tail
            print(string)
            del_count += 2
            del_flg = True

print(del_count)

### FIXED CODE ###

# -*- coding: utf-8 -*-

string = input()

red_count  = string.count('0')
blue_count = string.count('1')

print(min(red_count, blue_count) * 2)
R,G,B,N=map(int,input().split())

RL=(N+R-1)//R
if RL*F>N:
    RL=RL-1

cnt=0
for r in range(RL+1):
    GL=(N-r*R+G-1)//G
    for g in range(GL+1):
        if (r*R+g*G)>N:continue
        if (N-r*R-g*G)%B==0:
            cnt+=1

print(cnt)

### FIXED CODE ###

R, G, B, N = map(int, input().split())

ans = 0
for i in range(int(N / R) + 1):
    for j in range(int((N - i * R) / G) + 1):
        if ((N - (i * R + j * G)) % B == 0):
            ans += 1
print(ans)
import collections
n = int(input())
S = [list(input()) for i in range(n)]
Sc = [collections.Counter(i) for i in S]


if n == 1:
    ans = "".join(S[0].sort())
    print(ans)
else:
    counter = Sc[0] & Sc[1]
    for i in range(2, len(Sc)):
        counter = counter & Sc[i]

    Sclist = list(counter.elements())
    Sclist.sort()
    ans = "".join(Sclist)

    print(ans)


### FIXED CODE ###

import collections
n = int(input())
S = [list(input()) for i in range(n)]
Sc = [collections.Counter(i) for i in S]


if n == 1:
    S[0].sort()
    ans = "".join(S[0])
    print(ans)
else:
    counter = Sc[0] & Sc[1]
    for i in range(2, len(Sc)):
        counter = counter & Sc[i]

    Sclist = list(counter.elements())
    Sclist.sort()
    ans = "".join(Sclist)

    print(ans)
from collections import Counter

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

C = Counter(A).most_common()
L = len(C)

if L <= K:
  print(0)
  exit()

ans = 0
cnt = 0
for v in C.values():
  cnt += 1
  if K < cnt:
    ans += v
    
print(ans)


### FIXED CODE ###

from collections import Counter

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

C = Counter(A).most_common()
L = len(C)

if L <= K:
  print(0)
  exit()

ans = 0
cnt = 0
for k,v in C:
  cnt += 1
  if K < cnt:
    ans += v
    
print(ans)
n=int(input())
a=list(map(int.input().split()))
a.sort(reverse=True)
ans=0
x=n
for i in range(1,n):
  ans+=a[i//2]
print(ans)

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
ans=0
x=n
for i in range(1,n):
  ans+=a[i//2]
print(ans)
N, A = map(int, input().split())  # N枚数のカード, 平均をAにしたい
X = tuple(map(int, input().split()))  # N枚のカードの中身

dp = [[[0]*(50*N+1) for _ in range(N+1)] for _ in range(N+1)]

dp[0][0][0] = 1  # 0枚の中から0枚選んで合計が0になる選び方が1通りある

for i in range(N):
    for j in range(N+1):
        for s in range(50*N+1):
            if s >= X[i]:  # 今見ているのはX[i], これをどうするかで遷移先を変更する
                dp[i+1][j+1][s] += dp[i][j][s-X[i]]  # 追加する余裕がある場合は追加する
            dp[i+1][j][s] += dp[i][j][s]  # 何も追加しない
ans = 0
for i in range(1, N+1):
    ans += dp[N][i][i*A]
print(ans)


### FIXED CODE ###

N, A = map(int, input().split())  # N枚のカード, 平均をAにしたい

X = tuple(map(int, input().split()))  # カードリスト

# [カードの総枚数][選んだカードの枚数][今の総和]
dp = [[[0]*(50*N+1) for _ in range(N+1)] for _ in range(N+1)]

# 0枚の中から0枚選んで総和が0になるパターンは1つ
dp[0][0][0] = 1

for i in range(N):
    for j in range(N+1):
        for k in range(N*50+1):
            if dp[i][j][k]:  # 今の状態を未来へ遷移させる処理
                dp[i+1][j][k] += dp[i][j][k]  # 何も加えず未来へ
                dp[i+1][j+1][k+X[i]] += dp[i][j][k]  # 今見ているカードを加えて未来に遷移

ans = 0
for i in range(1, N+1):
    ans += dp[N][i][i*A]

print(ans)
import math
N = int(input())
a = list(map(int, input().split()))


def lcm(m, n):
    return (m // math.gcd(m, n)) * n


mod = 10**9+7
lc = a[0]
for i in range(N):
    lc = lcm(lc, a[i])
ans = 0
for i in range(N):
    ans += (lc // a[i])
print(ans % mod)


### FIXED CODE ###

import fractions
N = int(input())
a = list(map(int, input().split()))


def lcm(m, n):
    return (m // fractions.gcd(m, n)) * n


mod = 10**9+7
lc = a[0]
for i in range(N):
    lc = lcm(lc, a[i])
ans = 0
for i in range(N):
    ans += (lc // a[i])
print(ans % mod)