Harryxun/stf_run huggingface dataset:
import math
a, b = map(int, input().split())
print(math.ceil((a + b) / x))

### FIXED CODE ###

import math
a, b = map(int, input().split())
print(math.ceil((a + b) / 2))
S = input()
s_list=[]
string= ""
AGCT = ["A", "G", "C", "T"]
for s in S:
    if s in AGCT:
        string += s
    else:
        s_list.append(string)
        string=""
max(map(len, s_list))

### FIXED CODE ###

S = input()
s_list=[]
string= ""
AGCT = ["A", "G", "C", "T"]
for s in S:
    if s in AGCT:
        #string = string + s
        string += s
    else:
        s_list.append(string)
        string=""
s_list.append(string)
print(max(map(len, s_list)))
a, b, c = (int(i) for i in input().split())
if a*b >= c:
  return c
else:
  return a*b

### FIXED CODE ###

n, a, b = (int(i) for i in input().split())
if n*a > b:
  print(b)
else:
  print(n*a)
from sys import stdin
import operator as op
import numpy
import math

def combination_table(N):
	C = []
	for i in range(N+1):
		C.append([0] * (N+1))
	for i in range(N+1):
		for j in range(i+1):
			if (j==0 or j==i):
				C[i][j] = 1
			else:
				C[i][j] = C[i-1][j-1]+C[i-1][j]
	return C

if __name__ == "__main__":
	N, A, B = stdin.readline().split(" ")
	N = int(N)
	A = int(A)
	B = int(B)
	V = []
	line = stdin.readline().split(" ")
	unique_elements = dict()
	for e in line:
		V.append(int(e)) 
		if not int(e) in unique_elements:
			unique_elements[int(e)] = 1
		else:
			unique_elements[int(e)] += 1
	V.sort(reverse=True)

	C = combination_table(3)

	# find optimal selections between A and B
	optimal = [A]
	highest_avg = -1
	for i in range(A, B+1):
		avg = float(sum(V[:i])) / float(i)
		if (avg > highest_avg):
			highest_avg = avg
			optimal = [i] # reset the list
		elif (avg == highest_avg):
			if not i in optimal:
				optimal.append(i)

	total = 1
	for e in optimal:
		# unique elements and count in for optimal value
		op_elemements = dict()
		for i in range(e):
			if V[i] in op_elemements:
				op_elemements[V[i]] += 1
			else:
				op_elemements[V[i]] = 1

		# find the sum
		for key, value in op_elemements.items():
			# print (unique_elements[key], value, C[unique_elements[key]][value])
			total = total * C[unique_elements[key]][value]

	print ("{:6f}".format(highest_avg))
	print (int(total))


### FIXED CODE ###

from sys import stdin

def combination_table(N):
	C = []
	for i in range(N+1):
		C.append([0] * (N+1))
	for i in range(N+1):
		for j in range(i+1):
			if (j==0 or j==i):
				C[i][j] = 1
			else:
				C[i][j] = C[i-1][j-1]+C[i-1][j]
	return C

if __name__ == "__main__":
	N, A, B = stdin.readline().split(" ")
	N = int(N)
	A = int(A)
	B = int(B)
	V = []
	line = stdin.readline().split(" ")
	unique_elements = dict()
	for e in line:
		V.append(int(e)) 
		if not int(e) in unique_elements:
			unique_elements[int(e)] = 1
		else:
			unique_elements[int(e)] += 1
	V.sort(reverse=True)

	C = combination_table(N)

	# find optimal selections between A and B
	a_th_val_pos = 0
	a_th_val_num = 0
	highest_avg = float(sum(V[:A])) / float(A)
	for i in range(N):
		if V[i] == V[A-1]:
			a_th_val_num += 1
			if i < A:
				a_th_val_pos += 1


	cnt = 0
	if a_th_val_pos == A:
		for i in range(A, B+1):
			cnt += C[a_th_val_num][i]
	else:
		cnt += C[a_th_val_num][a_th_val_pos]

	print ("{:6f}".format(highest_avg))
	print (cnt)
def f(n):
    cnt = 0
    while n != 0:
        n //= 2
        cnt += 1
    return cnt

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

cnt = f(k)
ans = 0
num = n
for i in range(n):
    if k // (i+1) < 2**(cnt - 1):
        cnt -= 1
    ans += (1 / num)*(0.5 ** cnt)
print(ans)

### FIXED CODE ###

import math

def f(n):
    cnt = 0
    while n != 0:
        n //= 2
        cnt += 1
    return max(cnt,1)

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

cnt = f(k)
ans = 0
num = n
for i in range(n):
    while cnt != 0 and k / (i+1) <= 2**(cnt - 1):
        cnt -= 1
    ans += (1 / num)*math.pow(0.5,cnt)
print(ans)
n,x = map(int,input().split())
a = list(map(int,input().split()))

if sum(a) ==x:
    print(n)
else:
    a.sort()
    for i in range(n):
        if x >= a[i]:
            ans += 1
            x -= a[i]
        else:
            break




print(ans-1)

### FIXED CODE ###

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

if sum(a) ==x:
    print(n)
else:
    a.sort()
    for i in range(n):
        if x >= a[i]:
            ans += 1
            x -= a[i]
        else:
            break

    if ans == n:
        ans -= 1


    print(ans)
n,k = map(int,input().split())

m=abs(n-k)

mm=k%m
mmm=k-mm

if mmm >= mm:
    ans = mm
else:
    ans = mmm

print(str(ans))

### FIXED CODE ###

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

mm=n%k
mmm=k-mm

if mmm >= mm:
    ans = mm
else:
    ans = mmm

print(str(ans))
a,b,c,d = inpl()
print(max(0,(min(b,d)-max(a,c))))

### FIXED CODE ###

from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

a,b,c,d = inpl()
print(max(0,(min(b,d)-max(a,c))))
A = input()
B = input()
C = input()
K = input()

result = 0

for i in K:
    if A != 0:
        result = result - 1;
        A = A - 1;
    elif A == 0 and B != 0:
        #result変わらず
        B = B - 1;
    elif A == 0 and B == 0:
        result = result - 1;
        C = C - 1;
    else:
        break

print(result)


### FIXED CODE ###

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

if a >= k:
    print(k)
    exit()

if k-a-b <= 0:
    print(a)
    exit()

print(a-(k-a-b))
x = 753
s = input()
ans=100
for i in range(len(s)-2):
	if(abs(x-int(s[i:i+3]))<ans):
		ans=abs(x-int(s[i:i+3))
print(ans)

### FIXED CODE ###

x = 753
s = input()
ans=10**10
for i in range(len(s)-2):
	if(abs(x-int(s[i:i+3]))<ans):
		ans=abs(x-int(s[i:i+3]))
print(ans)
N, K = map(int, input().split())
Dlist = [1,1,1,1,1,1,1,1,1,1]
for i in range(K):
  D = int(input())
  Dlist[D]=0

while True:
  f = True
  Nx = str(N)
  for i in range(len(Nx)):
    if Dlist[int(Nx[i])] == 0:
      f = False
  if f:
    print(N)
    break
  else:
    N += 1

### FIXED CODE ###

N, K = map(int, input().split())
DL = list(map(int, input().split()))
Dlist = [1,1,1,1,1,1,1,1,1,1]
for i in range(len(DL)):
  Dlist[DL[i]]=0

while True:
  f = True
  Nx = str(N)
  for i in range(len(Nx)):
    if Dlist[int(Nx[i])] == 0:
      f = False
  if f:
    print(N)
    break
  else:
    N += 1
s = input()
k = int(input())

for i, v in enumerate(s):
  if i == k:

if s[0] != 1:
  print(s[0])
elif k != 1:
  print(s[1])
else:
  print("1")

### FIXED CODE ###

s = input()
k = int(input())

for i, v in enumerate(s):
  if i == k-1:
      print(v)
      exit()
  elif v != "1": 
      print(v)
      exit()
h, n = map(int, input().split())
p = [0] * n
c = [0] * n

inf = 1e9 + 1

for i in range(n):
    pp, cc = map(int, input().split())
    p[i] = pp
    c[i] = cc
    
dp = [inf] * (h + max(p))
dp[0] = 0

for i in range(n):
    for j in range(h):
        dp[j + p[i]] = min(dp[j + p[i]], dp[j] + c[i])
    
print(min(dp[h:]))


### FIXED CODE ###

h, n = map(int, input().split())
p = [0] * n
c = [0] * n

inf = 1e9 + 1

for i in range(n):
    pp, cc = map(int, input().split())
    p[i] = pp
    c[i] = cc
    
dp = [inf] * (h + max(p))
dp[0] = 0

for i in range(n):
    for j in range(h):
        dp[j + p[i]] = min(dp[j + p[i]], dp[j] + c[i])
    
print(min(dp[h:]))
n,l = map(int,input().split())
sam = []

for i in range(n):
    sam.append(input())

sam.sort()

print("".join(sam))

### FIXED CODE ###

import math

if sorted(input().split())==['5','5','7']:
    print('YES')
else:
    print('NO')
x, a = map(int, input())
if x < a:
  print(0)
else:
  print(10)

### FIXED CODE ###

x, a = map(int, input().split())
if x < a:
  print(0)
else:
  print(10)
A,B,C=map(int,input().split())
K=int(input())
if()
for i in range(0,K+1):
    for j in range(0,K+1-i):
        for k in range(0,K+1-i-j):
            #print('{},{},{}'.format(i,j,k))
            if(A*(2**i) < B*(2**j) and B*(2**j) < C*(2**k)):
                if(i==j==k==0):
                    pass
                else
                    print('Yes')
                    exit()

print('No')


### FIXED CODE ###

A,B,C=map(int,input().split())
K=int(input())

for i in range(0,K+1):
    for j in range(0,K+1-i):
        for k in range(0,K+1-i-j):
            #print('{},{},{}'.format(i,j,k))
            if(A*(2**i) < B*(2**j) and B*(2**j) < C*(2**k)):

                print('Yes')
                exit()

print('No')
N, X =map(int,input().split())
a = list(map(int,input().split()))
x = 0
count = 0
while x <= X:
    x += a[count]
    count += 1
print(count)

### FIXED CODE ###

N, X =map(int,input().split())
a = list(map(int,input().split()))
x = 0
count = 0
for i in range(len(a)+1):
    count += 1
    if not i == len(a):
        x += a[i]
    else:
        break
    if x > X:
        break
print(count)
k = input()
text = "ACL"*k
print(k)

### FIXED CODE ###

k = int(input())
text = "ACL" * k
print(text)
return x*x*x;

### FIXED CODE ###

n = input()

print n*n*n;
N,M=map(int,input().split())
e=[int(x)-1 for x in input().split()]
p=[i for i in range(N)]
r=[0]*N

def find(x):
	if p[x]!=x:
		p[x]=find(p[x])
	return p[x]

def unite(x,y):
	x=find(x)
	y=find(y)
	if x==y:
		return

	if r[x]<r[y]:
		p[x]=y
	else:
		p[y]=x
		if r[x]==r[y]:
			r[x]+=1

def same(x,y):
	return find(x)==find(y)

for i in range(M):
	x,y=map(int,input().split())
	unite(x-1,y-1)

c=0
for i in range(N):
	if same(i,e[i]):
		c+=1

print(c)


### FIXED CODE ###

a,b,c,d=map(int,input().split())
print('Yes' if abs(a-c)<=d or (abs(a-b)<=d and abs(b-c)<=d) else 'No')
N = int(input())
A = list(input())
R = []
B = []
G = []
for i in range(N):
  if A[i] == "R":
    R.append(i)
  elif A[i] == "G":
    G.append(i)
  else:
    B.append(i)
ans = 0
for i in range(len(R)):
  for j in range(len(G)):
    for k in range(len(B)):
      if (max(R[i], G[j], B[k]) + min(R[i], G[j], B[k]))/2 != (R[i], G[j], B[k])/3:
        ans += 1
print(ans)
        


    

### FIXED CODE ###

N = int(input())
A = list(input())
ans = A.count("R")*A.count("G")*A.count("B")
for i in range(N-2):
  for j in range(i+1, N-1):
    k = 2*j-i
    if k<N and A[k] != A[i] and A[k] != A[j] and A[i] != A[j]:
      ans -= 1
print(ans)
a = list(map(int,input().split()))

if a == 1:
    print("Hello World")
else:
    b = int(input())
    c = int(input())
    print(b+c)

### FIXED CODE ###

a = int(input())

if a == 1:
    print("Hello World")
else:
    b = int(input())
    c = int(input())
    print(b+c)
n=int(input())
a=list(map(int,input().split()))
li = [0]*9
for i in a:
  if i < 400:
    li[0]+=1
  elif i < 800:
    li[1]+=1
  elif i < 1200:
    li[2]+=1
  elif i < 1600:
    li[3]+=1
  elif i < 2000:
    li[4]+=1
  elif i < 2400:
    li[5]+=1
  elif i<2800:
    li[6]+=1
  elif i<3200:
    li[7]+=1
  else:
    li[8]+=1
li_ = [i for i in li[:-1] if i>0]
num = len(li_)
if num==0:
  print(1,n)
else:
  print(num, num + li[-1])


### FIXED CODE ###

r,g,b=map(int,input().split())
n=100*r+10*g+b
if n%4==0:
  print("YES")
else:
  print("NO")
S = str(input())

if S[1:4] = 'YAKI'
    print('Yes')
else:
    print('No')


### FIXED CODE ###

s = input()
answer = 'Yes' if s[:4] == 'YAKI' else 'No'
print(answer)
A, B, K = map(int, input().split())
l = [int(x) for x in range(A, B + 1)]
ans = []
for i in range(K):
	ans.append(l[i])
l.reverse()
for j in range(K):
	ans.append(l[j])
ans.sort()
for k in ans:
	print(k)

### FIXED CODE ###

A, B, K = map(int, input().split())
if 2 * K > B - A + 1:
	for i in range(A, B + 1):
		print(i)
else:
	for i in range(A, A + K):
		print(i)
	for j in range(B - K + 1, B + 1):
		print(j)
N, M = map(int, input().split())

group_list = []
group_index = [0] * N

for _ in range(M):
    a, b = map(int, input().split())
    if group_index[a-1] == 0 and group_index[b-1] == 0:
        group_index[a-1] = len(group_list) + 1
        group_index[b-1] = len(group_list) + 1
        group_list.append(set([a, b]))

    elif group_index[a-1] == 0:
        group_index[a-1] = group_index[b-1]
        group_list[group_index[b-1] - 1].add(a)

    elif group_index[b-1] == 0:
        group_index[b-1] = group_index[a-1]
        group_list[group_index[a-1] - 1].add(b)

    elif group_index[a-1] != group_index[b-1]:
        group_id_b = group_index[b-1] - 1
        for p in group_list[group_id_b]:
            group_index[p-1] = group_index[a-1]
            group_list[group_index[a-1] - 1].add(p)
        group_list[group_id_b].clear()

print(max([len(g) for g in group_list]))

### FIXED CODE ###

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

if M == 0:
    print(1)
    exit()

group_list = []
group_index = [0] * N

for _ in range(M):
    a, b = map(int, input().split())
    if group_index[a-1] == 0 and group_index[b-1] == 0:
        group_index[a-1] = len(group_list) + 1
        group_index[b-1] = len(group_list) + 1
        group_list.append(set([a, b]))

    elif group_index[a-1] == 0:
        group_index[a-1] = group_index[b-1]
        group_list[group_index[b-1] - 1].add(a)

    elif group_index[b-1] == 0:
        group_index[b-1] = group_index[a-1]
        group_list[group_index[a-1] - 1].add(b)

    elif group_index[a-1] != group_index[b-1]:
        if len(group_list[group_index[a-1] - 1]) > len(group_list[group_index[b-1] - 1]):
            group_id_b = group_index[b-1] - 1
            for p in group_list[group_id_b]:
                group_index[p-1] = group_index[a-1]
                group_list[group_index[a-1] - 1].add(p)
            group_list[group_id_b] = set()
        else:
            group_id_a = group_index[a-1] - 1
            for p in group_list[group_id_a]:
                group_index[p-1] = group_index[b-1]
                group_list[group_index[b-1] - 1].add(p)
            group_list[group_id_a] = set()

print(max([len(g) for g in group_list]))
import numpy as np
N = int(input())

ARR = []

for i in range(N):
    ARR.append([int(s) for s in input().split(" ")])

PRR = []

for i in range(N):
    PRR.append([int(s) for s in input().split(" ")])

def calculate(n, arr, prr):
    arr = np.array(arr)

    brr = []
    for i in range(1,2 ** 10):

        mask = np.zeros(10)

    return brr

result = calculate(N, ARR, PRR)
print(max(result))



### FIXED CODE ###

n = int(input())

frr = []

for i in range(n):
    frr.append([int(s) for s in input().split(" ")])

prr = []

for i in range(n):
    prr.append([int(s) for s in input().split(" ")])

# n = 2
#
# frr = [
#     [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
#     [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
# ]
#
# prr = [
#     [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],
#     [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1]
# ]


res = []
for i in range(1,2 ** 10):
    count = [0 for s in range(n)]

    mask = []
    for j in range(10):
        m =  i >> j & 1
        mask.append(m)
        if m == 1:
            for k in range(n):
                if frr[k][j] == 1:
                    count[k] = count[k] + 1

    mm = []
    for index,c in enumerate(count):
        mm.append(prr[index][c])

    res.append(sum(mm))

print(max(res))
n, s = map(int, input())
print("Yes" if 500*n >= s else "No")

### FIXED CODE ###

n, s = map(int, input().split())
print("Yes" if 500*n >= s else "No")
def pow2(n):
	res = 1
	for i in range(0, n):
		res *= 2
	return res

counter = [0]
N, K = map(int, raw_input().split())
for i in range(1, N+1):
	m = i
	cnt = 1
	while m < K:
		m *= 2
		cnt += 1
	counter.append(cnt)
sum = 0L
for i in range(1, N+1):
	sum += long(pow2(count[1]-count[i]))
sum *= 10000000000
dv = long(N)*long(pow2(count[1]))

print sum
print dv

### FIXED CODE ###

def pow2(n):
	res = 1
	for i in range(0, n):
		res *= 2
	return res

counter = [0]
N, K = map(int, raw_input().split())
for i in range(1, N+1):
	m = i
	cnt = 0
	while m < K:
		m *= 2
		cnt += 1
	counter.append(cnt)
sum = 0
for i in range(1, N+1):
	sum += pow2(counter[1]-counter[i])
dv = N*pow2(counter[1])
print float(sum)/float(dv)
K = int(input())
count = 1
rem = 7 % K

if K % 2 == 0:
    print(-1)
elif rem % K == 0:
    print(1)
else:
    while (rem % K) != 0:
        count += 1
        rem += 7 * pow(10, count-1, mod=K) % K
    print(count)


### FIXED CODE ###

K = int(input())
count = 1
rem = 7 % K

if K % 2 == 0:
    print(-1)
elif rem % K == 0:
    print(1)
else:
    while (rem % K) != 0 and count <= K:
        count += 1
        rem += 7 * pow(10, count-1, mod=K) % K
    if count <= K:
        print(count)
    else:
        print(-1)
import sys                          
import sympy                        
                                    
n = int(sys.stdin.readline())       
                                    
def isPrime(n):                     
    if n < 2:                       
        return False                
    for i in range(2,int(n**0.5)+1):
        if n%i==0:                  
            return False            
    return True                     
                                    
def divisors(n):                    
    l = []                          
    for i in range(2, n):           
        if n % i == 0:              
            l.append(n)             
    return l                        
                                    
def calc(n):                        
    used = set()                    
    a = 0                           
    c = True                        
    c1 = []                         
    ds = sympy.divisors(n)          
    m = max(ds)                     
    for d in ds:                    
        if not isPrime(d):          
            continue                
        v = d                       
        i = 1                       
        while v <= m:               
            c1.append(v)            
            i += 1                  
            v = d ** i              
    c1.sort()                       
    while c:                        
        c = False                   
        for d in c1:                
            if d in used:           
                continue            
            if n % d != 0:          
                continue            
            n //= d                 
            a += 1                  
            c = True                
            used.add(d)             
            break                   
    return a                        
                                    
print(calc(n))                      

### FIXED CODE ###

import sys

n = int(sys.stdin.readline())

def isPrime(n):
    if n < 2:
        return False
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False
    return True

def divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]

def calc(n):
    used = set()
    a = 0
    c = True
    c1 = []
    ds = divisors(n)
    m = max(ds)
    for d in ds:
        if not isPrime(d):
            continue
        v = d
        i = 1
        while v <= m:
            c1.append(v)
            i += 1
            v = d ** i
    c1.sort()
    while c:
        c = False
        for d in c1:
            if d in used:
                continue
            if n % d != 0:
                continue
            #print(n, d)
            n //= d
            a += 1
            c = True
            used.add(d)
            break
    return a

print(calc(n))
def is_integer(n):
    try:
        float(n)
    except ValueError:
        return False
    else:
        return float(n).is_integer()


import numpy as np
N,D = list(map(int,input().split()))
 
lis =[list(map(int,input().split())) for i in range(N)]
lis_np = np.array(lis)
counter = 0
for i in range(N-1):
    for j in range(i+1,N):
        kyori = (sum((lis_np[:][i] - lis_np[:][j])**2))**0.5
        if is_integer(kyori):
            counter += 1
print(counter)


### FIXED CODE ###

import numpy as np
N,D = list(map(int,input().split()))
 
lis =[list(map(int,input().split())) for i in range(N)]
lis_np = np.array(lis)
counter = 0
for i in range(N-1):
    for j in range(i+1,N):
        kyori = (sum((lis_np[:][i] - lis_np[:][j])**2))**0.5
        if kyori == int(kyori):
            counter += 1
        
print(counter)
A, B =int(input().split())

if A >= 13:
    print(B)
elif A >= 6:
    print(B//2)
else:
    print(0)

### FIXED CODE ###

A, B = map(int, input().split())

if A >= 13:
    print(B)
elif A >= 6:
    print(B//2)
else:
    print(0)
n = int(input())
an = input()
an = an.split()

dif = 999999999

for i in range(n-1):
    for r in range(i+1, n):
        a = int(an[i])
        b = int(an[r])

        abs = abs(a-b)
        if abs < dif:
            dif = abs

print(dif)


### FIXED CODE ###

n = input()
an = input()
an = an.split()
list = []

for i in an:
    i = int(i)
    list.append(i)
min_an = min(list)
max_an = max(list)

print(max_an - min_an)
a,p = map(int,input().split())
print((a*b+p)//2)

### FIXED CODE ###

a,p = map(int,input().split())
print((a*3+p)//2)
n = input()
EdgeLength=input()
edgeLength=[int(i) for i in EdgeLength]
N = int(n)

sorted.edgeLength()

sumL = 0
sumLength = [sumL += edgeLength[i] for i in range(1,N)]

if edgeLength[0] < sumL:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

n = input()
EdgeLength=input().split()
#print(EdgeLength)
N = int(n)
EdgeLength = [int(i) for i in EdgeLength]

#list(map(int, EdgeLength))

EdgeLength.sort()
#print(EdgeLength)

sumL = sum(EdgeLength) - EdgeLength[N-1]
#print(sumL)


if EdgeLength[N-1] < sumL:
    print("Yes")
else:
    print("No")
import sys
dataset = sys.stdin.readlines()

seq = 0

while dataset[seq] != '-\n':
 s = dataset[seq]
 len = len(s) - 1
 s = s[:len]
 seq += 1
 n = int(dataset[seq][0])
 seq += 1
 for i in range(seq, seq + n):
  h = int(dataset[i][0])
  s = s[h:] + s[0:h]
 print(s)
 seq += n
 

### FIXED CODE ###

import sys
dataset = sys.stdin.readlines()

seq = 0

while dataset[seq] != '-\n':
 s = dataset[seq]
 l = len(s) - 1
 s = s[:l]
 seq += 1
 n = dataset[seq]
 l = len(n) - 1
 n = int(n[:l])
 seq += 1
 for i in range(seq, seq + n):
  h = dataset[i]
  l = len(h) - 1
  h = int(h[:l])
  s = s[h:] + s[0:h]
 print(s)
 seq += n
while True:
    a, op, b = (str, input().split())

    a = int(a)
    b = int(b)
    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 True:
    a, op, b = (input().split())
    x = int(a)
    y = int(b)
    if op == "?":
        break
    elif op == "-":
        print(x - y)
    elif op == "+":
        print(x + y)
    elif op =="*":
        print (x * y)
    elif op == "/":
        print (x // y)
n = int(input())
a = list(map(int, input().split()))
return max(a) - min(a)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
print(max(a) - min(a))
N=input()
mod=N%10
if mod=3:
  print('bon')
elif mod=0,1,6,8:
  print('pon')
else:
  print('hon')


### FIXED CODE ###

N=int(input())
mod=N%10
if mod==3:
    print('bon')
elif mod== 0 or mod== 1 or mod== 6 or mod== 8:
    print("pon")
else:
    print('hon')
from math import sqrt
x1, y1, x2, y2 = (int(i) for i in input().split())
d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(d)

### FIXED CODE ###

from math import sqrt
x1, y1, x2, y2 = (float(i) for i in input().split())
d = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(d)
n = int(input())
anagrams = ["".join(sorted(input())) for i in range(n)]
print(sum([math.factorial(i-1) for i in pd.DataFrame(anagrams, columns=["word"]).groupby("word")["word"].count().values]))

### FIXED CODE ###

n = int(input())
anagrams = ["".join(sorted(input())) for i in range(n)]
from collections import defaultdict
d = defaultdict(list)
for i in range(n):
    d[anagrams[i]].append(i)
from scipy.misc import comb
cnt=0
for k, v in d.items():
    cnt+=comb(len(v), 2, exact=True)
print(cnt)
a = input()

if a >= 30:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a = int(input())

if a >= 30:
  print('Yes')
else:
  print('No')
v=int(input())

v=v%10
if v=3:
    print("bon")
elif v%2==1:
    print("pon")
else:
    print("hon")


### FIXED CODE ###

v=int(input())

v=v%10
if v==3:
    print("bon")
elif v==0 or v==1 or v==6 or v==8:
    print("pon")
else:
    print("hon")