Harryxun/stf_run huggingface dataset:
import numpy as np

num = int(input())

words = []
for _ in range(num):
    words.append(input())

words = tuple(words)

d = {}
for word in words:
    if word in d:
        d[word] += 1
    else:
        d[word] =1


# keyをndarrayで取得
keys = np.array([a[0] for a in d.items()])

# valueをndarrayで取得
values = np.array([a[1] for a in d.items()])

# valueがmaxであるkeyを探してくる
keys_of_max_val = keys[values == values.max()]

keys_of_max_val.sort()

print('\n'.join(keys_of_max_val))

### FIXED CODE ###

import numpy as np

num = int(input())

words = []
for _ in range(num):
    words.append(input())

words = tuple(words)

d = {}
for word in words:
    if word in d:
        d[word] += 1
    else:
        d[word] =1


# keyをndarrayで取得
keys = np.array([a[0] for a in d.items()])

# valueをndarrayで取得
values = np.array([a[1] for a in d.items()])

# valueがmaxであるkeyを探してくる
keys_of_max_val = keys[values == values.max()]

keys_of_max_val.sort()

print('\n'.join(keys_of_max_val))
import sys
i=0
L=list(input())
N=len(L)
if N==1:
  print(0)
  sys.exit()
for j in range(N):
  i=0
  while True:
    if L[i]!=L[i+1]:
      L.pop(i)
      L.pop(i)
      if L==[]:
        sys.exit()
    i+=1
    if i>len(L)-2:
      break
print(N-len(L))

### FIXED CODE ###

S=input()
a=S.count("1")
b=S.count("0")
print(min(a,b)*2)
a=input()
print(a+a**2+a**3)

### FIXED CODE ###

a=int(input())
print(a+a**2+a**3)
from collections import defaultdict
from heapq import heappop, heappush

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


class Graph(object):
    def __init__(self):
        self.edges = defaultdict(list)
        self.nodes = set()

    def add_edge(self, src, dst, weight=1):
        self.edges[src].append((dst, weight))
        self.nodes.add(src)
        self.nodes.add(dst)


def BellmanFord(graph, start):
    N = len(graph.nodes)
    dist = [float('-inf')] * N
    dist[start] = 0
    prev = [None] * N

    for _ in range(N):
        for u, l in graph.edges.items():
            for v, weight in l:
                if dist[v] < dist[u] + weight:
                    dist[v] = dist[u] + weight
                    prev[v] = u
    return dist


def topological_sort(graph):
    g = graph.edges
    N = len(graph.nodes)

    indeg = [0] * N
    for v in g:
        for u, _ in g[v]:
            indeg[u] += 1

    S = [i for i in range(N) if indeg[i] == 0]
    L = []

    while S:
        u = S.pop()
        L.append(u)
        for v, _ in g[u]:
            indeg[v] -= 1
            if indeg[v] == 0:
                S.append(v)
    return L


g = Graph()
for _ in range(M):
    a, b, c = map(int, input().split())
    g.add_edge(a - 1, b - 1, c)

if len(topological_sort(g)) == N:
    dist = BellmanFord(g, 0)
    print(dist[N - 1])
else:
    print('inf')


### FIXED CODE ###

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


class BellmanFord(object):
    def __init__(self, edges, n_nodes, start):
        self.edges = edges
        dist = [float('inf')] * n_nodes
        dist[start] = 0
        prev = [None] * n_nodes

        for _ in range(n_nodes - 1):
            for u, v, weight in edges:
                if dist[u] == float('inf'):
                    continue
                if dist[v] > dist[u] + weight:
                    dist[v] = dist[u] + weight
                    prev[v] = u
        self.dist = dist
        self.prev = prev

    def check(self, goal=None):
        if goal is None:
            for u, v, weight in self.edges:
                if self.dist[v] > self.dist[u] + weight:
                    return False
            return True
        else:
            negative = [False] * N
            for _ in range(N):
                for u, v, weight in self.edges:
                    if self.dist[u] == float('inf'):
                        continue
                    if negative[u] or self.dist[v] > self.dist[u] + weight:
                        negative[v] = True
            return not negative[goal]


edges = [None] * M
for i in range(M):
    a, b, c = map(int, input().split())
    edges[i] = (a - 1, b - 1, -c)

bf = BellmanFord(edges, N, 0)
if bf.check(N - 1):
    print(-bf.dist[N - 1])
else:
    print('inf')
s = input()
t = input()
cnt = 0
for i in range(3):
  if s[i] == t[i]:
  cnt += 1
print(cnt)

### FIXED CODE ###

s = input()
t = input()
cnt = 0
for i in range(3):
  if s[i] == t[i]:
  	cnt += 1
print(cnt)
#Branch on Condition - Sorting Three Numbers

num=list(map(int,input().split()))
bubble_sort(num)
print(num[0],num[1],num[2])

def bubble_sort(arr):
    change = True
    while change:
        change = False
        for i in range(len(arr) - 1):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                change = True
    return arr


### FIXED CODE ###

#Branch on Condition - Sorting Three Numbers

num=list(map(int,input().split()))
num.sort()
print(num[0],num[1],num[2])
a, b = map(int, input().sprit(" "))

count = 0
n = 1
while True:
  if n >= b:
    break
  n += a -1
  count += 1
  
print(count)
  

### FIXED CODE ###

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

count = 0
n = 1
while True:
  if n >= b:
    break
  n += a - 1
  count += 1
  
print(count)
# -*- coding: utf-8 -*-
N = int, input()
print(N)
num = str(N[1])
char_list = list(num)
sum = 0
for i in range(len(char_list)):
    sum += int(char_list[i])

if N[1] % sum == 0:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

# -*- coding: utf-8 -*-
N = int, input()
num = str(N[1])
char_list = list(num)
sum = 0
for i in range(len(char_list)):
    sum += int(char_list[i])

if int(N[1]) % sum == 0:
    print("Yes")
else:
    print("No")
S = int(input())

h = str(S//3600)
M = S%3600

m = str(M//60)

s = str(M%60)
print(h+":"0+m+":"+s)

### FIXED CODE ###

S = int(input())

h = str(S//3600)
M = S%3600

m = str(M//60)

s = str(M%60)
print(h+":"+m+":"+s)
n = int(input())
c = set([])
for i in range(1,10):
  for j in range (1,10):
    c.add(i * j)
print("Yes") if n in c else print("No")
    

### FIXED CODE ###

n = [int(i) for i in input().split(" ")]
if max(n) < 10:
  print(n[0] * n[1])
else:
  print(-1)
M, N = map(int, input().split())
if M = N:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

n, m = map(int, input().split())
if n == m:
    print('Yes')
else:
    print('No')
n,m = map(int,input().split())
SC = [list(map(int,input().split())) for __ in range(m)]

flag = False
l = [0]*3
for i in range(m):
    l[SC[i][0]-1] = SC[i][1]
    if flag == True:
        break
    for j in range(1,m-i):
        if SC[i][0] == SC[j][0]:
            if l[SC[i][0]-1] != l[SC[j][0]-1]:
                print('-1')
                flag = True
                break
    
if flag == False    
    if (l[n-1] == 0):
        print('-1')
    else:
        l = l[:n]
        s = ''
        for i in l:
            s += str(i)
        print(int(s))

### FIXED CODE ###

n,m = map(int, input().split())
 
sc = [tuple(map(int, input().split())) for _ in range(m)]
 
for i in range(1000):
    k = str(i)
    # all()：全ての要素がTrueであればTrueを返す
    # len(k)==nならば、左から一桁目が0である心配はない
    if len(k) == n and all([k[s-1]==str(c) for s,c in sc]):
        print(k)
        exit()
        
print('-1')
# 初期入力
import sys
input = sys.stdin.readline
T =list(input().strip())
if T[0] =="?":
    if T[1] =="?":
        T[0] ="P"
        T[1] ="D"
    elif T[1] =="D":
        T[0] ="P"
    else:
        T[0] ="D"


for i in range(1,len(T)-1):
    if T[i] =="?":
        if T[i-1] =="P":
            T[i] ="D"
        if T[i-1] =="D" and T[i+1] =="D":
            T[i] ="P"
        if T[i-1] =="D" and T[i+1] =="P":
            T[i] ="D"
        if T[i-1] =="D" and T[i+1] =="?":
            T[i] ="P"

if T[-1] =="?":
    T[-1] ="D"

print("".join(T))

### FIXED CODE ###

# 初期入力
import sys
input = sys.stdin.readline
T =list(input().strip())

    
if T[0] =="?":
    if len(T) ==1 :
        T[0] ="D"
    elif T[1] =="?":
        T[0] ="P"
        T[1] ="D"
    elif T[1] =="D":
        T[0] ="P"
    else:
        T[0] ="D"


for i in range(1,len(T)-1):
    if T[i] =="?":
        if T[i-1] =="P":
            T[i] ="D"
        if T[i-1] =="D" and T[i+1] =="D":
            T[i] ="P"
        if T[i-1] =="D" and T[i+1] =="P":
            T[i] ="D"
        if T[i-1] =="D" and T[i+1] =="?":
            T[i] ="P"

if T[-1] =="?":
    T[-1] ="D"

print("".join(T))
from sys import stdin
s=stdin.readline()
t=sdtin.readline()
count=0
for i in range(len(s)):
  if s[i]!=t[i]:
    count+=1
print(count)    

### FIXED CODE ###

from sys import stdin
s=stdin.readline()
t=stdin.readline()
count=0
for i in range(len(s)):
  if s[i]!=t[i]:
    count+=1
print(count)
n,a,b,c,d=map(int,input().split())
s=list(input())
fa=True
fb=True
ff=False
for i in range(a,c-1):
    if s[i]=="#" and s[i+1]=="#":
        fa=False
for i in range(b,d-1):
    if s[i]=="#" and s[i+1]=="#":
        fb=False

for i in range(a,d-1):
    if s[i]=="." and s[i+1]=="." and s[i+2]==".":
        ff=True
if c<d:
    if fa and fb:
        print("Yes")
    else:
        print("No")
else:
    if fa and fb and ff:
        print("Yes")
    else:
        print("No")


### FIXED CODE ###

n,a,b,c,d=map(int,input().split())
s=list(input())
fa=True
fb=True
ff=False
for i in range(a,c-1):
    if s[i]=="#" and s[i+1]=="#":
        fa=False
for i in range(b,d-1):
    if s[i]=="#" and s[i+1]=="#":
        fb=False
if c>d:
    for i in range(b-2,d-1):
        if s[i]=="." and s[i+1]=="." and s[i+2]==".":
            ff=True
if c<d:
    if fa and fb:
        print("Yes")
    else:
        print("No")
else:
    if fa and fb and ff:
        print("Yes")
    else:
        print("No")
l=map(int,input().split())
L=l[0]+l[1]
R=l[2]+l[3]

if R==L:
  print('Balanced')
elif R>L:
  print('Right')
else:
  print('Left')

### FIXED CODE ###

l=list(map(int,input().split()))
L=l[0]+l[1]
R=l[2]+l[3]

if R==L:
  print('Balanced')
elif R>L:
  print('Right')
else:
  print('Left')
import math
n,k=map(int,input().split())

if n == 1 or k == 1:
    print(0)
else:
    print(math.gcd(n,k))

### FIXED CODE ###

n,k=map(int,input().split())
n=int(n%k)
result=abs(k-n)

if n==0:
    print(0)
else:
    while result > abs(result-k):
        result=abs(result-k)
    print(result)
# -*- coding: utf-8 -*-

import sys
import six

def top_k_sort(data, k=3, reverse=True):
    data.sort(reverse=True)
    return data[:k]

def main():
    data = map(int, raw_input().split())

    data = [int(v) for v in argv[1:]]
    for h in top_k_sort(data):
        print(h)

if __name__ == '__main__':
    main()

### FIXED CODE ###

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

import sys

def top_k_sort(data, k=3, reverse=True):
    data.sort(reverse=True)
    return data[:k]

def main():
    data = []
    for line in sys.stdin:
        data.append(int(line))

    for h in top_k_sort(data):
        print(h)

if __name__ == '__main__':
    main()
from numba import jit

n, k = map(int, input().split())
arr = [0] + list(map(int, input().split())) + [0] * 1000


@jit
def solve(n, k, arr):
    INF = 1 << 60
    dp = [INF] * (n + 1000)
    dp[1] = 0

    for i in range(1, n):
        for k in range(1, k + 1):
            dp[i + k] = min(dp[i + k], dp[i] + abs(arr[i + k] - arr[i]))

    return dp[n]


print(solve(n, k, arr))

### FIXED CODE ###

n, k = map(int, input().split())
arr = list(map(int, input().split()))

# dp初期化
dp = [float("inf")] * n
dp[0] = 0

for i in range(1, n):
    dp[i] = min(dp[j] + abs(arr[i] - arr[j]) for j in range(max(i - k, 0), i))

print(dp[n - 1])
n = int(input())
if n < 105:
  print(0)
else:
  ans = 0
  for i in range(n,103,-2):
    count = 1
    for j in range(1,101,2):
      nj = n%j
      if nj == 0:
        count += 1
      if count == 9:
        break
    if count == 8:
      ans += 1
print(ans)

### FIXED CODE ###

n = int(input())
a = 0
for i in range(1,n+1,2):
  c = 0
  for j in range(1,n+1):
    if i%j == 0:
      c += 1
  if c == 8:
    a +=1
print(a)
N = input()

L = len(N)
ans = 0
buf = "0"
p = L - 1

if int(N) % 2 != 0:
    print(0)

else:
        count = int(N) // 10
        for j in range(1, 50):
            count += int(N) // ((5**j) * 10)

print(count)





### FIXED CODE ###

N = int(input())

if N % 2 != 0:
    print(0)
else:
    count = N // 10
    for j in range(1, 50):
        count += N // ((5**j) * 10)
    print(count)
def Input():
    matrix = []
    row, col = [int(x) for x in input().split()]
    i = row
    while i > 0:
        matrix.append([int(y) for y in input().split()])
        i -=  1
    return matrix

def calcTotalOfRowAndCol(matrix):
    for l in matrix:
        total = 0
        for val in l:
            total += val
        l.append(total)
    matrix.append([])
    for i in range(6):
        total = 0
        j = 0
        while j < 4:
            total += matrix[j][i]
            j += 1
        matrix[4].insert(i, total)

    return matrix

def Output(matrix):
    for l in matrix:
        print(' '.join(str(x) for x in l))

if __name__ == '__main__':
    matrix = Input()
    matrix = calcTotalOfRowAndCol(matrix)
    Output(matrix)

### FIXED CODE ###

def calcTotalOfRowAndCol(matrix, r, c):
    for l in matrix:
        total = 0
        for val in l:
            total += val
        l.append(total)
    matrix.append([])
    for i in range(c + 1):
        total = 0
        j = 0
        while j < r:
            total += matrix[j][i]
            j += 1
        matrix[r].insert(i, total)

if __name__ == '__main__':
    matrix = []
    row, col = [int(x) for x in input().split()]
    i = row
    while i > 0:
        matrix.append([int(y) for y in input().split()])
        i -= 1
    calcTotalOfRowAndCol(matrix, row, col)
    for l in matrix:
        print(' '.join(str(x) for x in l))
N, Y = map(int, input().split())
for x in range(0,N+1)
	for y in range(0,N+1)		
		for z in range(0,N+1)			
   			if Y==10000*x+5000*y+1000*z:
    			print(x,y,z)
    			exit()
print(-1,-1,-1)

### FIXED CODE ###

N, Y = map(int, input().split())
 
for x in range(N+1):
  for y in range(N-x+1):
    z = N - x - y
    if 10000 * x + 5000 * y + 1000 * z == Y:
      print(x,y,z)
      exit()
print(-1,-1,-1)
N = int(input())
mochis = []
for _ in range(N):
	mochis.append(int(input())

mochis = sorted(mochis, reverse=True)
dan = 0
for i in range(N):
	dan += 1
	if mochis[i] == mochis[i+1]:
		break

print(dan)


### FIXED CODE ###

N = int(input())
mochis = []
for _ in range(N):
	mochis.append(int(input()))

dan = len(list(set(mochis)))
print(dan)
#list_a = [int(x) for x in input().split()]
list_a = list(map(int,input().split()))

N = int(input())
#list_b = [int(x) for x in input().split()]
list_b = list(map(int,input().split()))

list_c = [0,0,0,0,0,0,0,0,0]
for i in range(N):
    for j in range(9):
        if list_a[j] == list_b[i]:
            list_c[j] = 1

flag=0
if list_c[0]==1 and list_c[1]==1 and list_c[2]==1:
    flag=1
if list_c[3]==1 and list_c[4]==1 and list_c[5]==1:
    flag=1
if list_c[6]==1 and list_c[7]==1 and list_c[8]==1:
    flag=1
if list_c[0]==1 and list_c[3]==1 and list_c[6]==1:
    flag=1
if list_c[1]==1 and list_c[4]==1 and list_c[7]==1:
    flag=1
if list_c[2]==1 and list_c[5]==1 and list_c[8]==1:
    flag=1
if list_c[0]==1 and list_c[4]==1 and list_c[8]==1:
    flag=1
if list_c[2]==1 and list_c[4]==1 and list_c[6]==1:
    flag=1
    
if flag == 1:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

list_1 = list(map(int,input().split()))
list_2 = list(map(int,input().split()))
list_3 = list(map(int,input().split()))

#n,m = map(int,raw_input().split())
#list_a = []
#for i in range(M) 
list_a=list_1


for x in list_2:
    list_a.append(x)


for x in list_3:
    list_a.append(x)


N = int(input())
#list_b = [int(x) for x in input().split()]
#list_b = list(map(int,input().split()))


list_b=[]
for k in range(N):
    b=int(input())
    list_b.append(b)


list_c = [0,0,0,0,0,0,0,0,0]
for i in range(N):
    for j in range(9):
        if list_a[j] == list_b[i]:
            list_c[j] = 1

flag=0
if list_c[0]==1 and list_c[1]==1 and list_c[2]==1:
    flag=1
if list_c[3]==1 and list_c[4]==1 and list_c[5]==1:
    flag=1
if list_c[6]==1 and list_c[7]==1 and list_c[8]==1:
    flag=1
if list_c[0]==1 and list_c[3]==1 and list_c[6]==1:
    flag=1
if list_c[1]==1 and list_c[4]==1 and list_c[7]==1:
    flag=1
if list_c[2]==1 and list_c[5]==1 and list_c[8]==1:
    flag=1
if list_c[0]==1 and list_c[4]==1 and list_c[8]==1:
    flag=1
if list_c[2]==1 and list_c[4]==1 and list_c[6]==1:
    flag=1
    
if flag == 1:
    print('Yes')
else:
    print('No')
N,M,K=map(int,input().split())
At=list(map(int,input().split()))
Bt=list(map(int,input().split()))

#０冊を初期値にする
A=[0]
B=[0]


for a in At:
    if A[-1]+a<K:
        A.append(A[-1]+a)

for b in Bt:
    if B[-1]+b<K:
        B.append(B[-1]+b)
print (A,B)

def is_ok(arg):
    # 条件を満たすかどうか？問題ごとに定義
    if Ak+B[arg]<=K:
        return True
    else:
        return False


def meguru_bisect(ng, ok):
    '''
    めぐる2分探査
    okはBの冊数たりうる値
    ngはBの冊数たり得ない値を入れる。
    '''

    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if is_ok(mid):
            ok = mid
        else:
            ng = mid
    return ok


Ak=0

maxBooks=0
for Ai in range(len(A)): 
    Ak=A[Ai]
    Bi=meguru_bisect(len(B),0) #len(B)は配列の要素数として使われるとき最大＋１
    if maxBooks<(Ai+Bi):
        maxBooks=Ai+Bi
print( maxBooks )




### FIXED CODE ###

N,M,K=map(int,input().split())
At=list(map(int,input().split()))
Bt=list(map(int,input().split()))

#０冊を初期値にする
A=[0]
B=[0]


for a in At:
    if A[-1]+a<=K:
        A.append(A[-1]+a)
    else:
        break
for b in Bt:
    if B[-1]+b<=K:
        B.append(B[-1]+b)
    else:
        break

def is_ok(arg):
    # 条件を満たすかどうか？問題ごとに定義
    if Ak+B[arg]<=K:
        return True
    else:
        return False


def meguru_bisect(ng, ok):
    '''
    めぐる2分探査
    okはBの冊数たりうる値
    ngはBの冊数たり得ない値を入れる。
    '''

    while (abs(ok - ng) > 1):
        mid = (ok + ng) // 2
        if is_ok(mid):
            ok = mid
        else:
            ng = mid
    return ok


Ak=0

maxBooks=0
for Ai in range(len(A)): 
    Ak=A[Ai]
    Bi=meguru_bisect(len(B),0) #len(B)は配列の要素数として使われるとき最大＋１
    if maxBooks<(Ai+Bi):
        maxBooks=Ai+Bi
print( maxBooks )
N, X, Y = map(int, input().split())
import numpy as np
from scipy.sparse.csgraph import shortest_path
from scipy.sparse import csr_matrix
inf = float("inf")

graph = np.zeros((N, N))
for i in range(N - 1):
    graph[i][i + 1] = 1
    graph[i + 1][i] = 1
graph[X - 1][Y - 1] = 1
graph[Y - 1][X - 1] = 1

shortest_paths = shortest_path(csr_matrix(graph), directed=False, method="D", unweighted=True)
ans = [0] * (N - 1)
for i in range(N):
    for j in range(N):
        if i != j:
            ans[shortest_paths[i][j]] += 1
for a in ans:
    print(a)


### FIXED CODE ###

from collections import deque
N, X, Y = map(int, input().split())

# G[v]: 頂点vに隣接する頂点list
# N: 頂点数
G = [[] for i in range(N)]
G[X - 1].append(Y - 1)
for i in range(N - 1):
    G[i].append(i + 1)
    G[i + 1].append(i)
# print(G)


def bfs(start):
    dist = [-1] * N
    que = deque([start])
    dist[start] = 0
    while que:
        v = que.popleft()
        d = dist[v]
        for w in G[v]:
            if dist[w] > -1:
                continue
            dist[w] = d + 1
            que.append(w)
    return dist


ans = [0] * N

for i in range(N - 1):
    # print(bfs(i))
    for ele in bfs(i)[i + 1:]:
        ans[ele] += 1
for a in ans[1:]:
    print(a)
x=list(map(int,input().split()))
for k in range(5)
    if x[k]==0:
        print(k+1)
    else:
        continue

### FIXED CODE ###

x=list(map(int,input().split()))
for k in range(5):
    if x[k]==0:
        print(k+1)
    else:
        continue
import numpy as np

a, b, n = map(int, input().split())
x = np.arange(1,n+1)
fx = (x*a)//b - (x//b)*a
print(np.max(fx))

### FIXED CODE ###

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

x = min(n,b-1)
ans = a*x//b - a*(x//b) 
print(ans)
import math

input = str(input()).split(" ")
for index in range(len(input)):
    input[index] = int(input[index])
x = input[0]
y = input[1]

def canBeDone(x,y):
    thingo = True
    while thingo:
        div = math.gcd(x,y)
        x = int(x/div)
        y = int(y/div)
        if (div == 1):
            thingo = False
    if (x == 1 and y == 1):
        return -1
    else:
        return 1

def test(x, y):
    if (canBeDone(x,y) == -1):
        return -1
    for index in range(1, abs(y)):
        if (x * index % y != 0 and abs(x * index) <= 10**(18)):
            return x * index
    return -1
print(test(x,y))


### FIXED CODE ###

x,y = map(int,input().split())
 
if x%y == 0:
  print(-1)
else:
  print(x)
a, b, c  = map(int, input().split())
if len(set(a, b, c)) == 1:
  	print('Yes')
else:
  	print('No')

### FIXED CODE ###

a, b, c = map(int, input().split())
l = {a, b, c}
if len(l) == 1:
  	print('Yes')
else:
  	print('No')
n = int(input())
an = list(map(int, input().split()))


from fractions import gcd
from functools import reduce

def lcm_base(x, y):
    return (x * y) // gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

lcma = lcm_list(an)
bn = []
for a in an:
    bn.append(lcma / a)

sumbn = sum(bn) % 1000000007

print(sumbn)

### FIXED CODE ###

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

from fractions import gcd
from functools import reduce

def lcm_base(x, y):
    return (x * y) // gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

lcma = lcm_list(an)
ans = 0
for i in range(n):
    ans += (lcma//an[i])
mod=10**9+7
print(ans%mod)
# -*- coding: utf-8 -*-
# 標準入力を取得
N, M, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))

# 求解処理
a, b = [0], [0]
for i in range(N):
    a.append(a[i] + A[i])
for j in range(M):
    b.append(b[i] + B[i])

ans, j = 0, M
for i in range(N + 1):
    if a[i] > K:
        break
    while b[j] > K - a[i]:
        j -= 1
    ans = max(ans, i + j)

# 結果出力
print(ans)


### FIXED CODE ###

# -*- coding: utf-8 -*-
# 標準入力を取得
N, M, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))

# 求解処理
a, b = [0], [0]
for i in range(N):
    a.append(a[i] + A[i])
for j in range(M):
    b.append(b[j] + B[j])

ans, j = 0, M
for i in range(N + 1):
    if a[i] > K:
        break
    while b[j] > K - a[i]:
        j -= 1
    ans = max(ans, i + j)

# 結果出力
print(ans)
S=input()
K=int(input())

i=0
while i<=len(S):
    if S[i]=="1":
        i+=1
    else:
        break

if K<=i-1:
    print(1)
else:
    print(S[i])

### FIXED CODE ###

S=input()
K=int(input())

i=0
while i<=len(S)-1:
    if S[i]=="1":
        i+=1
    else:
        break

if K<=i:
    print("1")
else:
    print(S[i])
#from functools import lru_cache
import sys
from itertools import product,combinations
from functools import reduce,lru_cache
import heapq
import numpy as np
def vfunc(f): return lambda *lst, **kwargs: list(map(lambda *x:f(*x,**kwargs),*lst))

def list_t(l): return vfunc(lambda *args:args)(*l)

def rvfunc(f): return lambda *lst, **kwargs: list(map(lambda *x:rvfunc(f)(*x,**kwargs) if all(vfunc(lambda y:isinstance(y,list))(x)) else f(*x,**kwargs),*lst))

def reader():return vfunc(lambda l:l.split())(sys.stdin.readlines())

n=int(reader()[0][0])
a=[]
while n!=0:
    a.append(n%10)
    n//=10
print('Yes' if sum(a)%9==0 else 'No')

### FIXED CODE ###

#from functools import lru_cache
import sys
def vfunc(f): return lambda *lst, **kwargs: list(map(lambda *x:f(*x,**kwargs),*lst))

def reader():return vfunc(lambda l:l.split())(sys.stdin.readlines())

n=reader()[0][0]
i=vfunc(lambda n:int(n))(n)
print('Yes' if sum(i)%9==0 else 'No')