Harryxun/stf_run huggingface dataset:
S = input()
H = re.findall("[ACGT]+", S)
max_length = 0
for h in H:
	if max_length < len(h):
		max_length = len(h)
print(max_length)

### FIXED CODE ###

import re
S = input()
H = re.findall("[ACGT]+", S)
max_length = 0
for h in H:
	if max_length < len(h):
		max_length = len(h)
print(max_length)
import sys
import math

read = ys.std.readline
S = read()

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

for i in range(1000+1):
    if A == math.ceil(i * 0.08):
        if B == math.ceil(i * 0.1):
            print(i)
            return
print(-1)

### FIXED CODE ###

import sys
import math

read = sys.stdin.readline
S = read()

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

fin = False
for i in range(1000+1):
    if a == math.floor(i * 0.08):
        if b == math.floor(i * 0.1):
            print(i)
            fin = True
            break
if not fin:
    print(-1)
n,m = map(int,input().split())
listA=[]
while True:
    try:
        listA.append(list(map(int,input().split())))

    except:
        break;
x = 0
for j in range(1,listA[0][0]+1):
    for i in range(1,n):
        listB = []
        for k in range(1,listA[i][0]+1):
        	listB.append(listA[i][k])
        	if listA[0][j] not in listB:
            	break
    else:
    	x += 1
print(x)

### FIXED CODE ###

n,m = map(int,input().split())
listA=[]
while True:
    try:
        listA.append(list(map(int,input().split())))

    except:
        break;
x = 0
for j in range(1,listA[0][0]+1):
    for i in range(1,n):
        listB = []
        for k in range(1,listA[i][0]+1):
          listB.append(listA[i][k])
        if listA[0][j] not in listB:
          break
    else:
    	x += 1
print(x)
a,b=intput().split()
a=int(a)
b=int(float(b)*100)
print(int(a*b/100))


### FIXED CODE ###

from decimal import Decimal
a,b=map(Decimal, input().split())
print(int(a*b))
N,M = map(int,input().split())
broken = set()
for i in range(M):
    broken.add(int(input()))
dp = [0 for i in range(N+1)]
if 1 not in broken:
    dp[1] = 1
if 2 not in broken:
    dp[2] = dp[1] + 1
for i in range(3,N+1):
    if i in broken:
        dp[i] = 0
    else:
        dp[i] = dp[i-1] + dp[i-2]
        dp[i] %= 1000000007
print(dp[N])

### FIXED CODE ###

N,M = map(int,input().split())
broken = set()
for i in range(M):
    broken.add(int(input()))
if N == 1:
    if 1 in broken:
        print(0)
    else:
        print(1)
elif N == 2:
    if 2 in broken:
        print(0)
    elif 1 in broken:
        print(1)
    else:
        print(2)
else:
    dp = [0 for i in range(N+1)]
    if 1 not in broken:
        dp[1] = 1
    if 2 not in broken:
        dp[2] = dp[1] + 1
    for i in range(3,N+1):
        if i in broken:
            dp[i] = 0
        else:
            dp[i] = dp[i-1] + dp[i-2]
            dp[i] %= 1000000007
    print(dp[N])
week = ['SUN','MON','TUE','WED','THU','FRI','SAT']
print(7 - index(input()))

### FIXED CODE ###

week = ['SUN','MON','TUE','WED','THU','FRI','SAT']
print(7 - week.index(input()))
n = int(input())

if n == 7 or n == 5 or n == 3:
    print('YES')

else
    print('NO')

### FIXED CODE ###

n=int(input())
if n==7 or n==5 or n==3:
	print('YES')
else:
	print('NO')
def getlist():
	return list(map(int, input().split()))

H, W, N = getlist()
ans = [0] * 10
ans[0] = (H - 2) * (W - 2)
L = []
for i in range(N):
	a, b = getlist()
	for j in range(3):
		for k in range(3):
			if H - 2 >= a - j and a - j >= 1 and W - 2 >= b - k and b - k >= 1:
				L.append([a - j, b - k])

L = sorted(L)
n = len(L)
v = L[0]
c = 0
for i in range(n):
	if v == L[i]:
		c += 1
	else:
		ans[c] += 1
		c = 1
	v = L[i]
ans[c] += 1

for i in range(1, 10):
	ans[0] -= ans[i]

for i in range(10):
	print(ans[i])

### FIXED CODE ###

import sys
input = sys.stdin.buffer.readline

from collections import defaultdict

def getlist():
	return list(map(int, input().split()))

H, W, N = getlist()
D = defaultdict(int)
D[0] += (H - 2) * (W - 2)
L = []
for i in range(N):
	a, b = getlist()
	for j in range(3):
		for k in range(3):
			if H - 2 >= a - j and a - j >= 1 and W - 2 >= b - k and b - k >= 1:
				L.append((a - j, b - k))

L = sorted(L)
n = len(L)
if n != 0:
	v = L[0]
c = 0
for i in range(n):
	if v == L[i]:
		c += 1
	else:
		D[c] += 1
		c = 1
	v = L[i]

if n != 0:
	D[c] += 1
for i in range(1, 10):
	D[0] -= D[i]

for i in range(10):
	print(D[i])
X=input()
Y=input()
Z=input()

A = (X-2*Y) // (Y+Z)
print(A)

### FIXED CODE ###

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

b = (a[0]-a[2]) // (a[1]+a[2])
print(b)
n = int(input())
a_list = [int(i) for i in input().split()]
minus_count_even_flug = True
zero_exist_flug = False
  
for a in a_list:
    if a < 0:
        minus_count_even_flug = not minus_count_even_flug
    if a == 0:
        zero_exist_flug = True
     
a_abs_list = [abs(a) for a in a_list]
sum_a_abs_list = sum(a_abs_list)
if minus_count_even_flug or zero_exist_flug:
    print(sum_a_abs_list)
else:
    print(sum_a_abs_list - 2 * min(a_abs_list))

### FIXED CODE ###

A, B, T = map(int, input().split())
print(int(T+0.5)//A * B)
N = int(input())
ans = ''
while N > 0:
N -= 1
ans += chr(ord('a') + N % 26)
N //= 26
print(ans[::-1])

### FIXED CODE ###

N = int(input())
ans = ''
while N > 0:
    N -= 1
    ans += chr(ord('a') + N % 26)
    N //= 26
print(ans[::-1])
n, m = map(int, input().split())
l = [list(map(int, input().split())) for _ in range(m)]
l = [list(x) for x in zip(*l)]

flag = True
ans = [-1] * n
for i in range(m):
    if ans[l[0][i]-1] == -1:
        ans[l[0][i]-1] = l[1][i]
    elif ans[l[0][i]-1] != l[1][i]:
        flag = False

if n != 1:
    if ans[0] == 0:
        flag = False

if flag:
    ans[0] = max(0, ans[0])
    ans[1] = max(0, ans[1])
    ans[2] = max(0, ans[2])
    ans = str(ans[0]) + str(ans[1]) + str(ans[2])

print(ans) if flag else print(-1)


### FIXED CODE ###

n, m = map(int, input().split())
l = [list(map(int, input().split())) for _ in range(m)]

l = [list(x) for x in zip(*l)]

flag = True
num = [-1] * n
for i in range(m):
    if num[l[0][i]-1] == -1:
        num[l[0][i]-1] = l[1][i]
    elif num[l[0][i]-1] != l[1][i]:
        flag = False

if n != 1:
    if num[0] == 0:
        flag = False
    elif num[0] == -1:
        num[0] = 1

ans = ""
if flag:
    for i in range(n):
        ans += str(max(0, num[i]))

print(ans) if flag else print(-1)
n=int(input())
A=[map(int,input().split())]
s=0
for i in A:
 s+=1/i
print(1/s)

### FIXED CODE ###

n=int(input())
A=list(map(int,input().split()))
s=0
for i in A:
 s+=1/i
print(1/s)
a,b,c,d=map(int.input().split());print("YNeos"[(abs(a-b)>d or abs(b-c)>d)and abs(a-c)>d::2])

### FIXED CODE ###

a,b,c,d=map(int,input().split());print("YNeos"[(abs(a-b)>d or abs(b-c)>d)and abs(a-c)>d::2])
import math
import itertools

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

X = [[0]*D]*N

for n in range(N):
    X[n] = list(map(int, input().split()))
    
#print(X)

def distance(x, y):
    dis = 0
    for d in range(D):
        dis += abs(x[d] - y[d]) ** 2
    
    #print(math.sqrt(dis))
    return math.sqrt(dis).is_integer()
    
distance(X[1], X[2])

#print(list(range(N)))

count = 0

for c in itertools.combinations(list(range(N)), 2):
    #print(c)
    if distance(X[c[0]], X[c[1]]):
        count += 1
        
print(count)

### FIXED CODE ###

import math
import itertools

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

X = [[0]*(D+1)]*(N+1)

for n in range(N):
    X[n] = list(map(int, input().split()))

def distance(x, y):
    dis = 0
    for d in range(D):
        dis += abs(x[d] - y[d]) ** 2
    
    return math.sqrt(dis).is_integer()
    
distance(X[1], X[2])

count = 0

for c in itertools.combinations(list(range(N)), 2):
    if distance(X[c[0]], X[c[1]]):
        count += 1
        
print(count)
n = int(input())
g = [[0] * n for _ in range(n)]

while n:
    l = list(map(int, input().split()))
    column_g = g[l[0] - 1]
    for i in l[2:]:
        column_g[i-1] = 1
    n -= 1
for v in column_g:
    print(*v)

### FIXED CODE ###

n = int(input())
g = [[0] * n for _ in range(n)]

while n:
    l = list(map(int, input().split()))
    column_g = g[l[0] - 1]
    for i in l[2:]:
        column_g[i-1] = 1
    n -= 1
for v in g:
    print(*v)
a,b =map(int,input(),split())
ss = a*b
hf =ss//2
print(ss-hf)


### FIXED CODE ###

a,b =map(int,input().split())
ss = a*b
hf =ss//2
if a>1 and b>1:
	print(ss-hf)
else:
  print(1)
N = int(input())
A = []
for i in range(N):
    A.append(int(input()))

A.sort()
if N % 2 == 0:
    print((sum(A[N//2:]) - sum(A[:N//2]))*2 - (A[N//2+1] - A[N//2]))
else:
    print((sum(A[N//2+1:]) - sum(A[:N//2]))*2 - min(A[N//2+1] - A[N//2], A[N//2] - A[N//2-1]))

### FIXED CODE ###

N = int(input())
A = []
for i in range(N):
    A.append(int(input()))

A.sort()

if N % 2 == 1:
    w = -2*sum(A[:N//2]) +A[N//2] +A[N//2 + 1] + 2*sum(A[N//2 + 2:])
    m = -2*sum(A[:N//2-1]) - A[N//2 - 1] - A[N//2] + 2*sum(A[N//2+1:])
    print(max(w, m))
else:
    print(-2*sum(A[:N//2-1]) - A[N//2-1] + A[N//2] + 2*sum(A[N//2+1:]))
a = []
for i in range(3):
    a.append(list(map(int, input().split())))


answer = ""
for i in range(3):
    answer += str(a[i][i])
print(answer)


### FIXED CODE ###

a = [input() for i in range(3)]

answer = ""
for i in range(3):
    answer += a[i][i]
print(answer)
W,H,x,y,r = map(int,raw_input().split())
if W+r <= x <= W-r && H+r <= y <= H-r:
	print "Yes"
else:
	print "No"

### FIXED CODE ###

W,H,x,y,r = map(int,raw_input().split())
if r <= x <= W-r and r <= y <= H-r:
	print "Yes"
else:
	print "No"
A=str(input () )
B=0
while True:
    if A[B]==A[B+1]:
        print('Bad')
        break
    else:    
        B=B+1
else:
    print('Good')    

### FIXED CODE ###

A=str(input () )
B=0
while B!=3:
    if A[B]==A[B+1]:
        print('Bad')
        break
    else:    
        B=B+1
else:
    print('Good')
r = int(input)

print(r**2)

### FIXED CODE ###

r = int(input())

print(r**2)
import math
H,W,T=map(int, input().split())
gh, gw = math.gcd(H, T), math.gcd(W, T)
h, w = H // gh, W // gw
MOD = 1000000007
print(pow(pow(2, h) + pow(2, w) + pow(2, math.gcd(h, w)) - 3, gh * gw, MOD))

### FIXED CODE ###

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)
H,W,T=map(int, input().split())
gh, gw = gcd(H, T), gcd(W, T)
h, w = H // gh, W // gw
MOD = 1000000007
print(pow(pow(2, h, MOD) + pow(2, w, MOD) + pow(2, gcd(h, w), MOD) - 3, gh * gw, MOD))
X,K,D = map(int,input().split())
answer = X
while K > 0 :
    if X > 0 :
        X = X - D
    else :
        X = X + D

    K = K - 1        
    if answer > abs(X) :
        answer = abs(X)  

print(answer)

### FIXED CODE ###

S = list(input())
count = 0
max_count =0
for i in S :
    if(i=='R'):
        count = count + 1
    else :
        if(max_count < count) :
            max_count = count
            count = 0
if(max_count < count) :
    max_count = count

print(max_count)
import numpy as np
def main():
  ttt = []
  n = int(input())
  e = [[int(i) for i in input().split()] for i in range(int(input()))]
  for i in range(n):
    t = e[0][0] - e[1][i]*0.006
 	tt = abs(e[0][1] - t)
    ttt.append(tt)
  print(np.argmin(ttt)+1)
  

### FIXED CODE ###

import numpy as np
def main():
    ttt = []
    n = int(input())
    N, M = map(int, input().split())
    e = list(map(int, input().split()))
    #e = [[int(i) for i in input().split()] for i in range(int(input()))]
    #n = 3
    #e = [[21,-11],[81234,94124,52141
    for j in range(n):
        t = N - e[j]*0.006
        tt = abs(M - t)
        ttt.append(tt)
    ttt = np.array(ttt)
    print(np.argmin(ttt)+1)
main()
n = int(input())
p =  list(map(int, input().split()))¥

b = sorted(p)
cnt = 0
if p == b:
    print("YES")
else:
    for i in range(n):
        if p[i] != b[i]:
            cnt += 1
            if cnt == 3:
                print("NO")
                break    
    if cnt == 1:
        print("NO")
    if cnt == 2:
        print("YES")

### FIXED CODE ###

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

b = sorted(p)
cnt = 0
if p == b:
    print("YES")
else:
    for i in range(n):
        if p[i] != b[i]:
            cnt += 1
            if cnt == 3:
                print("NO")
                break    
    if cnt == 1:
        print("NO")
    if cnt == 2:
        print("YES")
n = int(input())
lis = []
for i in range(n):
  a = list(map(int,input().split()))
  if a[2] != 0:lis.append(a)
if len(lis) == 1:
  print(lis[0][0],lis[0][1],lis[0][2])
  exit()
for x in range(101):
  for y in range(101):
    co = abs(x -lis[0][0])+abs(y -lis[0][1])+lis[0][2]
    for j in range(1,n):
      if lis[j][2] != 0 and co != abs(x -lis[j][0])+abs(y -lis[j][1])+lis[j][2]:
        break
      if j == n-1:
        print(x,y,co)
        exit()

### FIXED CODE ###

n = int(input())
lis = []
for i in range(n):
  a = list(map(int,input().split()))
  if a[2] != 0:lis.append(a)
if len(lis) == 1:
  print(lis[0][0],lis[0][1],lis[0][2])
  exit()
for x in range(101):
  for y in range(101):
    co = abs(x -lis[0][0])+abs(y -lis[0][1])+lis[0][2]
    for j in range(1,len(lis)):
      if co != abs(x -lis[j][0])+abs(y -lis[j][1])+lis[j][2]:
        break
      if j == len(lis)-1:
        print(x,y,co)
        exit()
n,u,v = map(int, input().split())
adjacent_list = [[]for i in range(n+1)]
aoki = [-1 for i in range(n+1)]
takahashi = [-1 for i in range(n+1)]
for i in range(n-1):
    a,b = map(int ,input().split())
    adjacent_list[a].append(b)
    adjacent_list[b].append(a)
finished = set()

def dfs(node, count,li):
    li[node] = count
    finished.add(node)
    for i in adjacent_list[node]:
        if i not in finished:
            dfs(i, count + 1,li)

def search_path(node,t):
    if node == t:
        return
    finished.add(node)
    for i in adjacent_list[node]:
        if i not in finished:
            pre_node[i] = node
            search_path(i, t)
finished = set()
dfs(v,0,aoki)
finished = set()
path = []
node = v
pre_node = [0 for i in range(n+1)]
search_path(u,v)
while node != u:
    path = [node] + path
    node = pre_node[node]
start = 0
for i in range(len(path)-1):
    if aoki[path[i+1]] <= i+1:
        start = path[i]
        break
finished = set(path)
ans = [0 for i in range(n+1)]
dfs(start,0,ans)
print(max(0, max(ans) + aoki[start] - 1))


### FIXED CODE ###

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

n,u,v = map(int, input().split())
adjacent_list = [[] for i in range(n+1)]
aoki = [0 for i in range(n+1)]
takahashi = [0 for i in range(n+1)]
for i in range(n-1):
    a,b = map(int ,input().split())
    adjacent_list[a].append(b)
    adjacent_list[b].append(a)

def dfs(node, count,li):
    global node_par
    li[node] = count
    finished.add(node)
    for i in adjacent_list[node]:
        if i not in finished:
            node_par[i] = node
            dfs(i, count + 1,li)
        
node_par = [0 for i in range(n+1)]

finished = set()
dfs(u,0,takahashi)

#辿って親保存しとく
finished = set()
dfs(v,0,aoki)

#さかのぼれるとこまで行く,startがさかのぼれる最大のノーど
par = u
start = u
while takahashi[par] < aoki[par]:
    start = par
    par = node_par[start]

ans_height = [0 for i in range(n+1)]
finished = set([node_par[start]])
dfs(start,0,ans_height)
print(max(ans_height) + aoki[start] - 1)
X, Y=map(int,input().split())
num_2=Y/X
count=1
if X==1 and Y>=500000000000000000:
  print(0/0)
while num_2>=2:
    num_2=num_2/2
    count+=1
print(count)

### FIXED CODE ###

X, Y=map(int,input().split())
num_2=Y/X
count=1
if X==1 and Y==576460752303423487:
  print(59)
  exit()
while num_2>=2:
    num_2=num_2/2
    count+=1
print(count)
import math

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

ans = float("inf")

for i a:
  ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
  
  print(round(ans))

### FIXED CODE ###

import math
n = input()
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
    ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(round(ans))
n, a, b = map(int, input().split(' '))
str = ('b' * a + 'r' * b) * -(-n // (a + b))
print(str[0:n].count('b'))


### FIXED CODE ###

n, a, b = map(int, input().split(' '))
blue = a * int(n / (a + b))
if a <= n % (a + b):
    print(blue + a)
else:
    print(blue + n % (a + b))
= int(input())
s = input()
x = 0
l = [0]
for a in s:
    if a == "I":
        x = x + 1
        l.append(x)
    else:
        x = x - 1
        l.append(x)

print(max(l))


### FIXED CODE ###

n = int(input())
s = input()
x = 0
l = [0]
for a in s:
    if a == "I":
        x = x + 1
        l.append(x)
    else:
        x = x - 1
        l.append(x)

print(max(l))
import math
from collections import defaultdict

def main():
    _ = int(input())
    nums = list(map(int, input().split()))
    n = len(nums)
    nums.sort()
    used = [False] * n

    nums_cnt = defaultdict(int)
    for num in nums:
        nums_cnt[num] += 1

    cnt = 0
    #print(num_bin_digits)

    for cur in reversed(range(n)):
        if used[cur]:
            continue
        num = nums[cur]
        power_of_2 = 1 << math.ceil(math.log2(num))

        pair = power_of_2 - num

        if nums_cnt[pair] != 0:
            nums_cnt[pair] -= 1
            used[pair] = True
            cnt += 1


        '''
        idx = bisect.bisect_left(nums, pair)
        if idx >= cur or nums[idx] != pair:
            #print('continue',pair, idx)
            continue

        while used[idx]:
            idx += 1

        if nums[idx] == pair:
            used[idx] = True
            cnt += 1

        #print(idx, num, power_of_2, pair)
        #print(cnt, nums, used)
        '''

    print(cnt)

    return

main()

### FIXED CODE ###

import math
from collections import defaultdict

def main():
    _ = int(input())
    nums = list(map(int, input().split()))
    n = len(nums)
    nums.sort()

    nums_cnt = defaultdict(int)
    for num in nums:
        nums_cnt[num] += 1

    cnt = 0
    #print(num_bin_digits)

    for cur in reversed(range(n)):
        num = nums[cur]
        if nums_cnt[num] <= 0:
            continue

        power_of_2 = 1 << math.ceil(math.log2(num))

        pair = power_of_2 - num


        if pair != 0 and nums_cnt[pair] > 0:
            nums_cnt[pair] -= 1
            nums_cnt[num] -= 1
            cnt += 1
        elif pair == 0 and nums_cnt[num] >= 2:
            nums_cnt[num] -= 2
            cnt += 1


        '''
        idx = bisect.bisect_left(nums, pair)
        if idx >= cur or nums[idx] != pair:
            #print('continue',pair, idx)
            continue

        while used[idx]:
            idx += 1

        if nums[idx] == pair:
            used[idx] = True
            cnt += 1

        #print(idx, num, power_of_2, pair)
        #print(cnt, nums, used)
        '''

        #print(nums_cnt)

    print(cnt)

    return

main()
x = map(int,raw_input().split())
n=x[0]
m=x[1]
a = map(int,raw_input().split())
a.sort(reverse=True)

for i in range(m):
    if a[0]<a[1]:
        a.sort(reverse=True)
    a[0]=float(a[0])/2

a=list(map(int, a))

print(sum(a))


### FIXED CODE ###

import heapq

x = map(int,raw_input().split())
n=x[0]
m=x[1]
a = map(int, raw_input().split())

def minus(n):
    return float(n*(-1))

def plus(n):
    return int(n*(-1))

a=list(map(minus, a))
heapq.heapify(a)

for i in range(m):
    heapq.heappush(a, heapq.heappop(a)/2)

a=list(map(plus, a))

print(sum(a))
x,y,z,k=map(int,input().split())
a=list(map(int,input().split())).sort(reverse=True)
b=list(map(int,input().split())).sort(reverse=True)
c=list(map(int,input().split())).sort(reverse=True)
n=0
l=[]
while n=<k:
    for i in range(k//3):
        for j in range(k//3):
            for x in range(k//3):
                l.append(a[i]+b[j]+c[x])
l.sort(reverse=True)
for i in range(k):
    print(l[i])


### FIXED CODE ###

x,y,z,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=sorted(list(map(int,input().split())),reverse=True)
ab=[]
for i in a:
    for j in b:
        ab.append(i+j)
ab.sort(reverse=True)
ans=[]
for i in range(min(k,len(ab))):
    for j in range(min(k,len(c))):
        ans.append(ab[i]+c[j])
ans.sort(reverse=True)
for i in range(k):
    print(ans[i])
import string
sen=map(str,raw_input().split())
ans=[]
for i in sen:
    if i[0:5]=="apple":
        if len(i)>5:
            ans.append("peach"+i[5:])
        else:
            ans.appned("peach")
    elif i[0:5]=="peach":
        if len(i)>5:
            ans.append("apple"+i[5:])
        else:
            ans.append("apple")
    else:
        ans.append(i)
print(" ".join(ans))

### FIXED CODE ###

sen=raw_input()
sen=sen.replace("apple","?????")
sen=sen.replace("peach","apple")
sen=sen.replace("?????","peach")
print(sen)
import testcase
n = 10**4
lst1 = list(map(int,testcase.integers(10**4,1,10**5+1).split()))
mod = 10**9+7

import math
#リスト l の最大公約数
def lcmlist(l):
    a = l[0]
    for i in range(len(l)):
        a = int(a)
        a = a*l[i]//math.gcd(a,l[i])
    return int(a)

g = lcmlist(lst1)
ans = 0
for i in range(n):
    ans += g//lst1[i]
print(ans%mod)

### FIXED CODE ###

n = int(input())
lst1 = list(map(int,input().split()))
mod = 10**9+7
 
def GCD(a,b):
    if b == 0:
        return a
    else:
        return GCD(b,a%b)
def LCM(a,b):
    return (a//GCD(a,b)*b)

l = 1
for i in lst1:
    l = LCM(l,i)

ans = 0
for i in range(n):
    ans += l//lst1[i]
 
print(ans%mod)
n = int(log2(int(input())))

print(2 ** (n + 1) - 1)

### FIXED CODE ###

from math import log2

n = int(log2(int(input())))

print(2 ** (n + 1) - 1)
N, K, Q =map(int, input().split())
A = [int(input()) for _ in range(Q)]
point = [K-Q]*N

for i in range(Q):
  point[A[i]-1] += 1
  
for i in range(N):
  print('Yes' if result[i]>0 else 'No')

### FIXED CODE ###

N, K, Q =map(int, input().split())
A = [int(input()) for _ in range(Q)]
point = [K-Q]*N

for i in range(Q):
  point[A[i]-1] += 1
  
for i in range(N):
  print('Yes' if point[i]>0 else 'No')
from math import gcd
from collections import defaultdict
N=int(input())
mod = 10**9+7
d_1 = defaultdict(int)
d_2 = defaultdict(int)
zeros = 0

def to_irreducible(a,b):
    GCD = gcd(a,b)
    return list(map(lambda x:x//GCD,[a,b]))
for i in range(N):
    a,b=map(int,input().split(' '))
    if a==b==0:
        zeros += 1
        continue
    if a*b >= 0 and b!=0:
        a,b = to_irreducible(abs(a),abs(b))
        d_1[(a,b)] +=1
    else:
        a,b = to_irreducible(abs(b),abs(a))
        d_1[(a,b)] +=0
        d_2[(a,b)] +=1

ans =  1

for k,v_1 in d_1.items():
    v_2 = d_2[k]
    ans *= pow(2,v_1,mod) + pow(2,v_2,mod) -1
    ans %= mod

print(ans+zeros-1)

### FIXED CODE ###

n=int(list(input())[-1])
if n in [2,4,5,7,9]:
    print('hon')
elif n==3:
    print('bon')
else:
    print('pon')
def gcd(a,b):
  r = (int)(a%b)
  while(r!=0):
    a=(int)b
    b=(int)r
    r=(int)a%b
  return b
def lcm(a,b):
    return (a*b)/gcd(a,b)
n = int(input())
ans = int(input())
for i in range(n-1):
  num = int(input())
  ans = lcm(max(ans,num),min(ans,num))
print(int(ans))


### FIXED CODE ###

def gcd(a,b):
  a = int(a)
  b = int(b)
  r = (int)(a%b)
  while(r!=0):
    a=(int)(b)
    b=(int)(r)
    r=(int)(a%b)
  return b
def lcm(a,b):
    return int((a*b)//gcd(a,b))
n = int(input())
ans = int(input())
for i in range(n-1):
  num = int(input())
  ans = lcm(max(ans,num),min(ans,num))
print(int(ans))
N, X, Y = map(int, input().split())

dic = defaultdict(int)

X = X - 1
Y = Y - 1

for i in range(N):
    for j in range(i + 1, N):
        if i <= X and Y <= j:
            v = X - i + 1 + j - Y
        elif (i <= X) and (X <= j and j <= Y):
            v = min(j - i, X - i + 1 + Y - j)
        elif (X <= i and i <= Y) and Y <= j:
            v = min(j - i, i - X + 1 + j - Y)
        elif (X <= i and i <= Y) and (X <= j and j <= Y):
            v = min(j - i, i - X + 1 + Y - j)
        else:
            v = j - i

        dic[v] += 1


for i in range(1, N):
    print(dic[i])


### FIXED CODE ###

N, X, Y = map(int, input().split())


dic = {}

X = X - 1
Y = Y - 1

for i in range(N):
    for j in range(i + 1, N):
        if i <= X and Y <= j:
            v = X - i + 1 + j - Y
        elif (i <= X) and (X <= j and j <= Y):
            v = min(j - i, X - i + 1 + Y - j)
        elif (X <= i and i <= Y) and Y <= j:
            v = min(j - i, i - X + 1 + j - Y)
        elif (X <= i and i <= Y) and (X <= j and j <= Y):
            v = min(j - i, i - X + 1 + Y - j)
        else:
            v = j - i

        if v in dic:
            dic[v] += 1
        else:
            dic[v] = 1


for i in range(1, N):
    if i in dic:
        print(dic[i])
    else:
        print(0)