Harryxun/stf_run huggingface dataset:
N = int(input())
A = list(map(int,input().split(' ')))

def myGCD(a,b):
    while b!=0:
        a,b = b,a%b
    return a

def list_gcd(numbers):
    tmp=numbers[0]
    for i in range(len(numbers)-1):
        tmp=min(tmp,myGCD(numbers[i],numbers[i+1]))
    return(tmp)

#print(list_gcd(A))

candidate=[0,0]
t1 = A[0]
candidate[0]=max(A[0],A[1])
candidate[1]=myGCD(A[0],A[1])
candidate[2]=myGCD(A[0],A[1])

for i in range(2,N):
    candidate[0]=myGCD(candidate[0],A[i])
    candidate[1]=candidate[1]
    candidate[2]=myGCD(candidate[2],A[i])
    candidate[0]=min(candidate[0],candidate[1])

#print(min(candidate))

print(max(candidate))

### FIXED CODE ###

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

def myGCD(a,b):
    if a == 0:
        return b
    while b!=0:
        a,b = b,a%b
    return a

L=[]
R=[]
for i in range(N):
    L.append(0)
    R.append(0)

for i in range(N-1):
    L[i+1]=myGCD(L[i],A[i])

for i in range(N-2,-1,-1):
    #print(i)
    R[i] = myGCD(R[i+1],A[i+1])

M=[]
for i in range(N):
    M.append(myGCD(R[i],L[i]))
#print(L)
#print(R)

print(max(M))
from decimal import *
 
a, b, c = map(Decimal, input().split())
if sqrt(a) + sqrt(b) < sqrt(c):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

from decimal import *
 
a, b, c = map(Decimal, input().split())
if a.sqrt() + b.sqrt() < c.sqrt():
    print('Yes')
else:
    print('No')
def main() :
    lst = input().split()
    stack = []
    for i in lst :
        if i == ""+"" :
            x = stack.pop()
            y = stack.pop()
            stack.append(x + y)

        elif i == "-" :
            x = stack.pop()
            y = stack.pop()
            stack.append(y - x)

        elif i == "*" :
            x = stack.pop()
            y = stack.pop()
            stack.append(x * y)

        else :
            stack.append(int(i))

    print(stack.pop())


if __name__ == "__main__" :
    main()

   

### FIXED CODE ###

def main() :
    lst = input().split()
    stack = []
    for i in lst :
        if i == "+" :
            x = stack.pop()
            y = stack.pop()
            stack.append(x + y)

        elif i == "-" :
            x = stack.pop()
            y = stack.pop()
            stack.append(y - x)

        elif i == "*" :
            x = stack.pop()
            y = stack.pop()
            stack.append(x * y)

        else :
            stack.append(int(i))

    print(stack.pop())


if __name__ == "__main__" :
    main()
A,B,C,X=map(int,input().split()) #500,100,50, total
#X=500*a+100*b+50*c

count=0
for a in range(A+1):
  for b in range(B+1):
    for c in range(C+1):
      if X==500*a+100*b+50*c:
        count=count+1
        
print(count)
        
        



### FIXED CODE ###

#A,B,C,X=map(int,input().split()) #500,100,50, total
#X=500*a+100*b+50*c
A=int(input())
B=int(input())
C=int(input())
X=int(input())
count=0
for a in range(A+1):
  for b in range(B+1):
    for c in range(C+1):
      if X==500*a+100*b+50*c:
        count=count+1
print(count)
S = input()

c = 0
for a, b in zip(s, s[-1]):
  if a == b:
    c += 1

print(len(S)-c)

### FIXED CODE ###

S = input()
l = len(S)
c = 0
for a, b in zip(S[:l//2+1], S[:l//2-1:-1]):
  if a != b:
    c += 1
print(c)
a,b=map(int,input())
if a+b==15:
  print("+")
elif a*b==15:
  print("*")
else:
  print("x")

### FIXED CODE ###

a,b=map(int,input().split())
if a+b==15:
  print("+")
elif a*b==15:
  print("*")
else:
  print("x")
from collections import Counter


N = int(input())
lstA = list(map(int, input().split()))
mod = 10**9 + 7
countA = Counter(lstA)


if N % 2:
    if countA[0] == 1 and all(countA[i] == 2 for i in range(2, N, 2)):
        ans = pow(2, N//2, mod)
    else:
        ans = 0
else:
    if all(countA[i] == 2 for i in range(1, N, 2)):
        ans = pow(2, N//2, mod)

print(ans)

### FIXED CODE ###

from collections import Counter


N = int(input())
lstA = list(map(int, input().split()))
mod = 10**9 + 7
countA = Counter(lstA)
ans = 0

if N % 2:
    if countA[0] == 1 and all(countA[i] == 2 for i in range(2, N, 2)):
        ans = pow(2, N//2, mod)
else:
    if all(countA[i] == 2 for i in range(1, N, 2)):
        ans = pow(2, N//2, mod)


print(ans)
import math
n = int(input())
lis = []
for i in range(n):lis.append(int(input()))
if lis[0] != 0:
    print("-1")
    exit()
cou = 0
print(lis,cou)
for k in range(n-1):
    if lis[n-(k+1)] > lis[n-(k+2)]:
        a =  math.ceil(lis[n-(k+1)] / (lis[n-(k+2)]+1))
        cou += a
        lis[n-(k+1)] = 0
        lis[n-(k+2)] = min(lis[n-(k+1)]-1,lis[n-(k+2)],math.ceil(lis[n-(k+1)]/a)-1)
    else:
        cou += lis[n-(k+1)]
        lis[n-(k+2)] -= lis[n-(k+1)]-1
        lis[n-(k+1)] = 0
    print(lis,cou)
print(cou)

### FIXED CODE ###

n = int(input())
lis = [int(input()) for i in range(n)]
if lis[0] != 0:print(-1);exit()
ans = 0
for i in range(n-1,0,-1):
    if lis[i] - lis[i-1] > 1:print(-1);exit()
    elif lis[i] - lis[i-1] == 1:ans += 1
    else:ans += lis[i]
print(ans)
b = []
c = []
for i in a:
	b.append(10-i % 10)
for i,j in zip(b,a):
	if max(b) != i:
		c.append(i+j)
	else:
		c.append(j)
print(sum(c))

### FIXED CODE ###

a = list(map(int,[input() for i in range(5)]))
b = 10
c = 0
for i in a:
	if i % 10 > 0:
		c += i + 10 - i % 10
		if b > i % 10:
			b = i % 10
	else:
		c += i
print(c-10+b)
#coding: utf-8
import numpy as np
N, M = map(int, input().split())
AB = np.array([list(map(int, input().split())) for _ in range(N)])
money = 0
col_num = 0
AB = AB[np.argsort(AB[:, col_num])]
if M <= AB[np.argmin(AB[:, 0]), 1]:
    money += AB[0, 0] * M
else:
    i = 0
    while M >= 0:
        money += AB[i, 0] * AB[i, 1]
        M -= AB[i, 1]
        if M <= 0:
          money += AB[i, 0] * M
        i += 1
print(money)

### FIXED CODE ###

#coding: utf-8
import numpy as np
N, M = map(int, input().split())
AB = np.array([list(map(int, input().split())) for _ in range(N)])
money = 0
col_num = 0
AB = AB[np.argsort(AB[:, col_num])]
if M <= AB[np.argmin(AB[:, 0]), 1]:
    money += AB[0, 0] * M
else:
    i = 0
    while M > 0:
        money += AB[i, 0] * AB[i, 1]
        M -= AB[i, 1]
        if M <= 0:
          money += AB[i, 0] * M
        i += 1
print(money)
n = int(input())
lst = input().split(" ")

dic = {}
for i, l in enumerate(lst):
  dic[int(l)] = i

ll = []
for i in range(1, n+1):
  ll.append(dic[i])
  
answer = " ".join(ll)
print(answer)

### FIXED CODE ###

n = int(input())
lst = input().split(" ")

dic = {}
for i, l in enumerate(lst):
  dic[int(l)] = i+1

ll = []
for i in range(1, n+1):
  ll.append(str(dic[i]))
  
answer = " ".join(ll)
print(answer)
a,b,c=[int(x) for x in input().split()]
count = 0
for d in range(a,b+1)
    elif c%d == 0 : count +=
print(count)


### FIXED CODE ###

a,b,c=[int(x) for x in input().split()]
count = 0
for d in range(a,b+1):
    if c%d == 0 : count += 1
print(count)
n = int(input())
map_list = []
for _ in range(n):
    map_list.append(input().split())

def function():
    x = int(map_list[0][0])
    y = int(map_list[0][1])
    h = int(map_list[0][2])

    for i in range(101):
        for j in range(101):
            cont_check = True
            H = abs(x - i) + abs(y - j) + h
            
            for k in range(n):
                x = int(map_list[k][0])
                y = int(map_list[k][1])
                h = int(map_list[k][2])

                if h != max(H - abs(x - i) - abs(y - j), 0):
                    cont_check = False
                    break
            if cont_check:
                return i, j, H

i, j, H = function()
print(i, j, H)

### FIXED CODE ###

n = int(input())
map_list = []
for _ in range(n):
    map_list.append(input().split())

def function():
    for i in range(101):
        if int(map_list[i][2]) > 0:
            x = int(map_list[i][0])
            y = int(map_list[i][1])
            h = int(map_list[i][2])
            break
        else:
            continue

    for i in range(101):
        for j in range(101):
            cont_check = True
            H = abs(x - i) + abs(y - j) + h
            
            for data in map_list:
                xx, yy, hh = map(int, data)
                if hh != max(H - abs(xx - i) - abs(yy - j), 0):
                    cont_check = False
                    break
            if cont_check:
                return i, j, H

i, j, H = function()
print(i, j, H)
import math
r=float(input())
C=math.pi
print("{0:.6f} {1:.6f}").format(C*r**2,C*2*r)

### FIXED CODE ###

import math
r=float(input())
C=math.pi
print("{0:.6f} {1:.6f}".format(C*r**2,C*2*r))
N = input()
s = 0
for n in N:
  s += int(n)
res = int(N) % s
if res == 0:
  print("Yes")
else
  print("No")

### FIXED CODE ###

N = input()
s = 0
for n in N:
  s += int(n)
res = int(N) % s
if res == 0:
  print("Yes")
else:
  print("No")
n=int(input())
lista=list(map(int,input().split()))
listb=list(map(int,input().split()))
listc=list(map(int,input().split()))
list=[]
for i in range(n):
  if lista[i]==lista[i-1]+1:
    list.append(lista[i])
vonus=0
for x in list:
  vonus+=listc[x-1]
print(sum(listb)+vonus)

### FIXED CODE ###

n=int(input())
lista=list(map(int,input().split()))
listb=list(map(int,input().split()))
listc=list(map(int,input().split()))
list=[]
for i in range(2,n+1):
  if lista[i-1]==lista[i-2]+1:
    list.append(lista[i-2])
vonus=0
for x in list:
  vonus+=listc[x-1]
print(sum(listb)+vonus)
A = list(int, input().split())
print(A.index(0) + 1)

### FIXED CODE ###

l = list(map(int,input().split()))
print (l.index(0)+1)
N = int(input())
v = list(map(int,input().split()))
while len(v) > 1:
  x = v.pop()
  v[-1] = (v[-1] + x)/2

print(v[0]) 

### FIXED CODE ###

N = int(input())
v = list(map(int,input().split()))
v.sort(reverse = True)

while len(v) > 1:
  x = v.pop()
  v[-1] = (x + v[-1]) /2
      
print(v[0])
x,n = map(int,input().split())
P = list(map(int,input().split()))
 
for i in range(101):
  xl = x - i
  xr = x + i
  if xl not in P:
    print(xl)
    break
  elif xr not in P:
    print(xr)
    break

### FIXED CODE ###

x=list(map(int,input().split()))
print(x.index(0)+1)
S = input()
T = input()
if (S in T) and (S[0] == T[0]) and (S[1] == T[1]):
  print('Yes')
else:
  print('No')
  


### FIXED CODE ###

S = input()
T = input()
if (S in T) and (S[0] == T[0]):
  if ((len(S) > 1) and (S[1] == T[1])) or (len(S) == 1):
    print('Yes')
else:
  print('No')
print(["error",A+B],[sum(list(map(int,input().split())))<10])


### FIXED CODE ###

A,B=map(int,input().split())
if A+B<10:
    print(A+B)
else:
    print("error")
import Queue
INF = 10**9+7
n = input()
p = []
for i in xrange(n):
    p.append(int(raw_input()))
dist = [10**7] * n
calc = [-1] * n
used = [False] * n
que = Queue.PriorityQueue()
que.put((0, 0))
dist[0] = 0
def dfs(pos, calc, used, f):
    if p[pos]==0:
        return pos
    if calc[pos]!=-1:
        return calc[pos]
    if used[pos]:
        return INF
    used[pos] = True
    calc[pos] = dfs(pos+p[pos], calc, used, p[pos])
    used[pos] = False
    return calc[pos]
while not que.empty():
    co, v = que.get()
    if dist[v] < co:
        continue
    for k in xrange(1, 7):
        go = v+k
        if go>=n:
            break
        if p[go] != 0:
            if calc[go]==-1:
                dfs(go, calc, used, 0)
            if calc[go]==INF:
                continue
            go = calc[go]
        if go==n-1:
            print dist[v]+1
            exit(0)
        if dist[v] + 1 < dist[go]:
            dist[go] = dist[v] + 1
            que.put((dist[go], go))

### FIXED CODE ###

import Queue
INF = 10**9
n = input()
p = [i+int(raw_input()) for i in xrange(n)]

used = [0] * n
idx = 0
for i in xrange(n):
    if p[i]!=i:
        path = []
        go = i
        idx += 1
        while go!=INF and p[go]!=go:
            if used[go]==idx:
                go = INF
                break
            used[go] = idx
            path.append(go)
            go = p[go]
        for e in path:
            p[e] = go

dist = [INF] * n
que = Queue.Queue()
que.put(0)
dist[0] = 0
while not que.empty():
    v = que.get()
    for k in xrange(1, min(7, n-v)):
        go = p[v+k]
        if go==n-1:
            print dist[v]+1
            exit(0)
        if go!=INF and dist[v] + 1 < dist[go]:
            dist[go] = dist[v] + 1
            que.put(go)
a,b=map(int,input().split())
if a%2==0 or b%2==0:
  print("No")
else:
  priint("Yes")

### FIXED CODE ###

a,b=map(int,input().split())
if a%2==0 or b%2==0:
  print("No")
else:
  print("Yes")
n = input()
s = ''
for c in n:
  if c == '1':
    s += '9'
  else:
  	if c == '9':
    	s += '1'
    else:
      s += c
print(s)
  

### FIXED CODE ###

n = input()
s = ''
for c in n:
  if c == '1':
    s += '9'
  else:
    if c == '9':
        s += '1'
    else:
        s += c
print(s)
print(sum(list(int,input().split())))

### FIXED CODE ###

S=input()
print(int(S[0])+int(S[1])+int(S[2]))
s = input()
x,y = map(int, input().split())
dp = [[False]*32001 for i in range(2)]

index = 0
while s[index] == 'F':
  index += 1
x -= index
dp_index = 1
for i in range(index, len(s)):
  num = 0
  while s[i] == 'F':
    num += 1
    i += 1
  for i in range(-8000, 8001):
    dp[dp_index][i] = dp[dp_index][i-num] or dp[dp_index[i+num]]
  dp_index = (dp_index+1) % 2

if dp[0][x] and dp[1][y]:
  print('Yes')
else:
  print('NO')

### FIXED CODE ###

import datetime
s = input()
x, y = map(int, input().split())
#print(datetime.datetime.now())
 
num_of_f = 0
for c in s:
    if c == 'F':
        num_of_f += 1
dp = [[[False] * 32001 for _ in range(2)] for _ in range(2)]
 
dp[0][0][0] = True
dp[0][1][0] = True
# print(dp)
index = 0
while index < len(s) and s[index] == 'F':
    index += 1
x -= index
xy_axis = 1
dp_index = 1
i = index + 1
num_of_f = index
while i < len(s):
    num = 0
    while i < len(s) and s[i] == 'F':
        num += 1
        i += 1
    num_of_f += num
    for j in range(-1 * num_of_f, num_of_f + 1):
        dp[dp_index][xy_axis][j] = dp[(dp_index + 1) % 2][xy_axis][j - num] or dp[(dp_index + 1) % 2][xy_axis][j + num]
    xy_axis = (xy_axis + 1) % 2
    if xy_axis == 1:
        dp_index = (dp_index + 1) % 2
    i += 1
 
# print(dp)
 
if dp[(dp_index + 1) % 2][0][x] and dp[(dp_index + xy_axis) % 2][1][y]:
    print('Yes')
else:
    print('No')
#print(datetime.datetime.now())
a,*b,c=input()
print(a+str(len(*b))+c)

### FIXED CODE ###

kk = input()
print(kk[0]+str(len(kk)-2) + kk[len(kk)-1:len(kk)-2:-1])
def main():
  n=int(input())
  a=sorted(list(map(int,input().split())))

  result=0
  dic={}
  dic[0]=0

  for i in range(1,a[-1]+100):
    if i in a:
      dic[i]=dic[i-1]+a.count(i)
    else:
      dic[i]=dic[i-1]

  #print(dic)

  for i in range(n-2):
    for j in range(i+1,n-1):
      if a[i]+a[j]>a[j+1]:
        temp=a[i]+a[j]
        #print(temp,a[j],a[-1])
        result+=dic[min(a[-1],temp-1)]-dic[a[j]]
        #print(a[i],a[j],a[j+1:],result)

  print(result)



if __name__ == '__main__':
    main()


### FIXED CODE ###

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

print(max(0,a-2*b))
w,h,x,y = map(int,input().split())
if w/x==2.0 and h//y==2.0:
    print(w*h/2,1)
else:
    print(w*h/2,0)

### FIXED CODE ###

w,h,x,y = map(int,input().split())
if x==0 or y==0:
    print("{:.9f}".format(w*h/2),0)
    exit()
if w/x==2.0 and h/y==2.0:
    print(w*h/2,1)
else:
    print(w*h/2,0)
if a*b%2 == 0:
  print("Even")
else:
  print("Odd")


### FIXED CODE ###

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

if a*b%2 == 0:
    print("Even")
else:
    print("Odd")
n = int(input())
a = list(map(int, input().split()))
a = [(i, v) for i, v in enumerate(a)]
a.sort(key=lambda x: x[1], reverse=True)

dp = [[-1] * (m + 1) for m in range(n + 1)]
# m: 何人選んだか, l: 左を選んだ人数
def f(m, l):
    if m == n: return 0
    if dp[m][l] != -1: return dp[m][l]
    r = n - m + l - 1
    i, v = a[m]
    if i >= l: dp[m + 1][l + 1] = f(m + 1, l + 1)
    if i <= r: dp[m + 1][l] = f(m + 1, l)
    return max(dp[m + 1][l + 1] + v * (i - l), dp[m + 1][l] + v * (r - i))
print(f(0, 0))

### FIXED CODE ###

import sys
sys.setrecursionlimit(2000 * 2)
n = int(input())
a = list(map(int, input().split()))
a = [(i, v) for i, v in enumerate(a)]
a.sort(key=lambda x: x[1], reverse=True)

dp = [[-1] * (m + 1) for m in range(n + 1)]
# m: 何人選んだか, l: 左を選んだ人数
def f(m, l):
    if m == n: return 0
    if dp[m][l] != -1: return dp[m][l]
    r = n - m + l - 1
    i, v = a[m]
    if i >= l: dp[m + 1][l + 1] = f(m + 1, l + 1)
    if i <= r: dp[m + 1][l] = f(m + 1, l)
    return max(dp[m + 1][l + 1] + v * (i - l), dp[m + 1][l] + v * (r - i))
print(f(0, 0))
x,k,d=map(int,input().split())
x=abs(x)
sa=x//d
ans=x
pbk,mbk=0,0
bk1,bk2,bk3=1,1,1
mansbk,pansbk=0,0
if sa>=k:
  ans=x-d*k
else:
  ans=x-d*sa
  k=k-sa
  for i in range(k):
    mansbk=abs(ans-d)
    pansbk=abs(ans+d)
    if mansbk!=pansbk:
      ans=min(mansbk,pansbk)
      if bk3!=1:
        bk1=min(mansbk,pansbk)
        bk2=max(mansbk,pansbk)
        ans=ans if (k-i)%2==0 else bk1
        break
      else:
        bk3=max(mansbk,pansbk) 
    else:
      ans=0 if (k-i)%2==0 else d
      break
    pbk=max(mansbk,pansbk)
    mbk=min(mansbk,pansbk)
print(ans)

### FIXED CODE ###

s=input()
ans=0
bk=0
for i in range(3):
  if s[i]=="R":
    bk+=1
  else:
    if ans<bk:
      ans=bk
    bk=0
if ans<bk:
  ans=bk
print(ans)
A, B, C, D, E, F= (int(i) for i in input().split())

dens=0
for a in range(30+1):
  for b in range(30+1):
    waterA=100*a*A
    waterAB=waterA+100*b*B
    if  waterA<= F and 0 < waterAB <= F:
      for c in range(100+1):
        for d in range(100+1):
          if waterAB+c*C+d*D <= F:
            if c*C+d*D <= (a*A+b*B)*E:
              if dens < (c*C+d*D)/(waterAB+c*C+d*D):
                dens=(c*C+d*D)/(waterAB+c*C+d*D)
                max=waterAB+c*C+d*D
              
print(max,int(max*dens))

### FIXED CODE ###

n = int(input())
a = int(input())

print(n*n-a)
A,B,C = map(int,input().split(' '))
K = int(input())

for i in range(K):
  max = max(A,B,C)
  max *= 2
print(A+B+C)  

### FIXED CODE ###

A,B,C = map(int,input().split(' '))
K = int(input())
x = max(A,B,C)
y = x*(1-2**K)/(1-2)
print(int(A+B+C+y))
#gcdは3.4.3だとfractionsにある
#from fractions import gcd

from math import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    a,b,c = mi()
    a,b = b,a
    a,c = c,a
    print(a,b,c)



main()





### FIXED CODE ###

#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    x,y,z = mi()
    y,x = x,y
    z,x = x,z
    print(x,y,z)


main()
N,A,B = map(int,input().split())
data = range(A,B+1)
if N-2>=0:
  print( (B − A)(N − 2) + 1)
elif N == 1:
  if A!=B:
    print('0')
  else:
    print('1')
else:
  print('0')

### FIXED CODE ###

N,A,B = map(int,input().split())
if A>B:
  print('0')
elif N == 1:
  if A!=B:
    print('0')
  else:
    print('1')
else:
  print((B-A)*(N-2)+1)
import math
a,b,x = map(float,input().split())

c = a/(2*b-2*x/a**2)
d = (2*x)/(a*b**2)
if x/a >= a*b/2:
  result = math.atan(c)
else:
  result = math.degrees(math.atan(d))
print(result)
  

### FIXED CODE ###

import math
a,b,x = map(float,input().split())

c = (2*b-(2*x)/(a*a))/a
d = (a*b*b)/(2*x)
if x/a >= a*b/2:
  result = math.degrees(math.atan(c))
else:
  result = math.degrees(math.atan(d))
print(result)
ans = []
for l in range(len(s)):
    for r in range(l + 1, K + 1):
        ans.append(s[l:r])
        
print(sorted(set(ans))[K - 1])

### FIXED CODE ###

s = input()
K = int(input())
ans = [s[l:l + r + 1] for l in range(len(s)) for r in range(K)]
print(sorted(set(ans))[K - 1])
import math
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

n = int(input())
arr = [int(i) for i in input().split()]

print(gcd(*arr))

### FIXED CODE ###

from fractions import gcd
N = int(input())
array = list(map(int,input().split()))
all_gcd = [0]*N
#calc from start to end
gcd_L = [array[0]]
for i in range(N-1):
  gcd_L.append(gcd(gcd_L[-1],array[i+1]))
  
#calc from end to start
gcd_R = [array[-1]]
for j in range(N-1,0,-1):
  gcd_R.append(gcd(gcd_R[-1],array[j-1]))
  
gcd_arr = []
  
for idx in range(N):
  if idx==0:
    gcd_arr.append(gcd_R[-2])
  elif idx==N-1:
    gcd_arr.append(gcd_L[-2])
  else:
    gcd_arr.append(gcd(gcd_L[idx-1],gcd_R[N-1-idx-1]))
print(max(gcd_arr))
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  mini = min(list(map(abs, ajis)))
  mini = mini * -1
  if mini in ajis:
    pass
  else:
    mini = mini * -1
  print(ajis)
  ajis.remove(mini)
  print(ajis)
  return sum(ajis)

print(apple_pie(range(1, int(n))))

### FIXED CODE ###

param = input()
s = list(map(int, list(str(param))))

pre = None
check = True
 
for i in s:
  if pre != None:
    if pre == i:
      print("Bad")
      check = False
      break
  pre = i
  
if check:
  print("Good")
S = list(input())
ans = 0
for i in range(0, len(S), 2):
    if S[i]!="h" or S[i+1]!="i":
        ans += 1
if ans==0:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

S = input()
list = ["hi","hihi","hihihi","hihihihi","hihihihihi"]
if S in list:
    print("Yes")
else:
    print("No")
N,K,Q=input()
c=[K-Q for i in range(N)]
for i in range(Q):
    A=input()
    c[A-1]++
for i in range(N):
    print("Yes" if c[i]>0 else "No")

### FIXED CODE ###

n,k,q = list(map(int, input().split()))
a = [k-q for i in range(n)]

for i in range(q):
  b = int(input())
  a[b-1] += 1
  
for i in range(n):
  if a[i] > 0:
    print("Yes")
  else:
    print("No")
i = 0
while 1:
    i+=1
    v = raw_input()
    if not v:
       break
    print ('Case {}: {}'.format(i,v))

### FIXED CODE ###

i = 0
while 1:
    i+=1
    v = raw_input()
    if v == '0':
       break
    print ('Case {}: {}'.format(i,v))
a,b,c=map(input().split())
print(a[0]+b[0]+c[0])

### FIXED CODE ###

print("A"+input()[8]+"C")
n = int(raw_input())
a = raw_input().split()

a.sort()

print (" ".join(map(str a)))

### FIXED CODE ###

n = int(raw_input())
a = map(int, raw_input().split())

a.sort()

print (" ".join(map(str, a)))
n,blue = map(int,input().split())
red = n-blue
mod = 10 ** 9 + 7

now = [1]
for i in range(1,red+2):
    next = []
    for j in range(min(i+1,blue+1)):
        if j == 0 or j == i:
            next.append(1)
        else:
            next.append((now[j-1]+now[j])%mod)
    now = next

  # print(now)
for i in range(1,blue+1):
    print((now[i] * pow(i,blue-i,mod))%mod)

### FIXED CODE ###

n,blue = map(int,input().split())
red = n-blue
mod = 10 ** 9 + 7

now = [1]
get = [1]
for i in range(1,red+2):
    next = []
    for j in range(min(i+1,blue+1)):
        if j == 0 or j == i:
            next.append(1)
        else:
            next.append((now[j-1]+now[j])%mod)
    now = next
for i in range(1,blue):
    next = []
    for j in range(i+1):
        if j == 0 or j == i:
            next.append(1)
        else:
            next.append((get[j-1]+get[j])%mod)
    get = next

  # print(now)
for i in range(1,blue+1):
    try:
  #        print(now[i],get[i-1])
        print((now[i] * get[i-1])%mod)
    except:
        print(0)