Harryxun/stf_run huggingface dataset:
n=int(input())
l=[]
for i in range(n):
    x,y=map(int,input().split())
    l.append([x,y])
l=sorted(l)
s=set()
for j in range(n-1):
    for k in range(j,n):
        s.add((l[k][0]-l[j][0],l[k][1]-l[j][1]))
s_l=sorted(list(s))
cnt=[0]*len(s_l)
dic={}
for i in range(len(s_l)):
    dic[s_l[i]]=i
for j in range(n-1):
    for k in range(j+1,n):
        cnt[dic[(l[k][0]-l[j][0],l[k][1]-l[j][1])]]+=1

print(n-max(cnt))


### FIXED CODE ###

n=int(input())
l=[]
for i in range(n):
    x,y=map(int,input().split())
    l.append([x,y])
l=sorted(l)
s=set()
for j in range(n-1):
    for k in range(j,n):
        s.add((l[k][0]-l[j][0],l[k][1]-l[j][1]))
s_l=sorted(list(s))
cnt=[0]*len(s_l)
dic={}
for i in range(len(s_l)):
    dic[s_l[i]]=i
for j in range(n-1):
    for k in range(j+1,n):
        cnt[dic[(l[k][0]-l[j][0],l[k][1]-l[j][1])]]+=1
if n==1:
    print(1)
    exit()
print(n-max(cnt))
import sys
sys.setrecursionlimit(10**6)
MOD = 10**9+7
N = int(input())
edge = [[] for _ in range(N+1)]
dp = [[0]*2 for i in range(100005)]
# dp[v][c]: 頂点vを色cの根とする部分木の塗り分け方の総数
# 葉が決まると順々に求まっていく
for i in range(N-1):
    x,y = map(int,input().split())
    edge[x].append(y)
    edge[y].append(x)

# 0:white,1:black
def dfs(v,last=-1):
    dp[v][0] = 1
    dp[v][1] = 1
    for nv in edge[v]:
        if nv == last:
            continue
        dfs(nv, v)
        dp[v][0] = dp[v][0] * ((dp[nv][0] + dp[nv][1]) % MOD) % MOD
        dp[v][1] = dp[v][1] * dp[nv][0] % MOD


dfs(1)
print(dp[1][0] + dp[1][1])MOD = 10**9+7
N = int(input())
edge = [[] for _ in range(N+1)]
dp = [[0]*2 for i in range(100005)]
# dp[v][c]: 頂点vを色cの根とする部分木の塗り分け方の総数
# 葉が決まると順々に求まっていく
for i in range(N-1):
    x,y = map(int,input().split())
    edge[x].append(y)
    edge[y].append(x)

# 0:white,1:black
def dfs(v,last=-1):
    dp[v][0] = 1
    dp[v][1] = 1
    for nv in edge[v]:
        if nv == last:
            continue
        dfs(nv, v)
        dp[v][0] = dp[v][0] * ((dp[nv][0] + dp[nv][1]) % MOD) % MOD
        dp[v][1] = dp[v][1] * dp[nv][0] % MOD


dfs(1)
print(dp[1][0] + dp[1][1])

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def main():
  MOD = 10**9+7
  N = int(input())
  edge = [[] for _ in range(N+1)]
  dp = [[0]*2 for i in range(100005)]
  # dp[v][c]: 頂点vを色cの根とする部分木の塗り分け方の総数
  # 葉が決まると順々に求まっていく
  for i in range(N-1):
      x,y = map(int,input().split())
      edge[x].append(y)
      edge[y].append(x)

  # 0:white,1:black
  def dfs(v,last=-1):
      dp[v][0] = 1
      dp[v][1] = 1
      for nv in edge[v]:
          if nv == last:
              continue
          dfs(nv, v)
          dp[v][0] = dp[v][0] * ((dp[nv][0] + dp[nv][1]) % MOD) % MOD
          dp[v][1] = dp[v][1] * dp[nv][0] % MOD


  dfs(1)
  print((dp[1][0] + dp[1][1])%MOD)
if __name__ == '__main__':
  main()
s=input()
a = list(map(int,input().split()))
x=len(a)
i=0
for k in range 1000000000:
    i=i+1
    for i in range x:
        a[i]=0.5*a[i]
        if a[i]%2=1:
            break
    else:
        continue
    break
h=i-1
print("h")



### FIXED CODE ###

s=input()
a = list(map(int,input().split()))
x=len(a)
f=0
for k in range(1000000000):
    f=f+1
    for i in range(x):
        if a[i]%2 == 1:
            break
        a[i]=0.5*a[i]
    else:
        continue
    break
print(f-1)
from sys import stdin
import math
from itertools import groupby

n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))

li.sort()

if li[0] == 0 and li[1] == 0:
    print(0)
    exit()

lin = []
for key, value in groupby(li):
    lin.append(len(list(value)))

point = 1

for i in lin:
    if i >= 3:
        print(0)
        exit()
    point *= 2
    point %= 10**9+7

print(point)

### FIXED CODE ###

from sys import stdin
import math
from itertools import groupby

n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))

li.sort()

if len(li) == 1:
    if li[0] != 0:
        print(0)
        exit()
    else:
        print(1)
        exit()

if li[0] == 0 and li[1] == 0:
    print(0)
    exit()
    
lin = []
for key, value in groupby(li):
    lin.append(len(list(value)))

point = 1

for i in lin:
    if i >= 3:
        print(0)
        exit()
    point *= math.factorial(i)
    point %= 10**9+7

print(point)
n , q = map(int, input().split())
r = [[]for i in range(n)]
s = [0]*n
v = [0]*n
for i in range(n-1):
    a , b = map(int, input().split())
    r[a-1].append(b-1)
    r[b-1].append(a-1)
for i in range(q):
    p , x = map(int, input().split())
    s[p-1]+=x

def dfs(now):
    v[now]=1
    for i in r[now]:
        if v[i]==0:
            s[i]+=s[now]
            dfs(i)
    return
dfs(0)
print(' '.join(list(map(str,s))))


### FIXED CODE ###

from collections import deque

n , q = map(int, input().split())
r = [[]for i in range(n)]
s = [0]*n
v = [0]*n
for i in range(n-1):
    a , b = map(int, input().split())
    r[a-1].append(b-1)
    r[b-1].append(a-1)
for i in range(q):
    p , x = map(int, input().split())
    s[p-1]+=x
d= deque()
d.append(0)
def bfs(now):
    v[now]=1
    while d:
        i = d.popleft()
        for j in r[i]:
            if v[j]==0:
                s[j]+=s[i]
                v[j]=1
                d.append(j)
    return
bfs(0)
print(' '.join(list(map(str,s))))
s=input()
l=[]
for i in range(2,len(s)-1):
    l.append(s[i])

k=s[1:s.index("C")]+s[s.index("C")+1:]

if s[0]=="A" and l.count("C")==1 and k==k.lower():
    print("AC")
else:
    print("WA")

### FIXED CODE ###

import sys
s=input()
l=[]
for i in range(2,len(s)-1):
    l.append(s[i])
if l.count("C")!=1:
    print("WA")
    sys.exit()
else:
    k=s[1:s.index("C")]+s[s.index("C")+1:]

if s[0]=="A" and l.count("C")==1 and k==k.lower():
    print("AC")
else:
    print("WA")
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import shortest_path

N, M = map(int, input().split())
edge_d = np.array([input().split() for _ in range(M)], dtype=np.int32)
edge_n = np.stack([np.arange(2, N + 1, dtype=np.int16),
                   np.arange(1, N, dtype=np.int16),
                   np.ones(N - 1, dtype=np.int8)]).T
edge = np.concatenate([edge_d, edge_d[:, [1, 0, 2]], edge_n]).T

matr = csr_matrix((edge[2], (edge[:2] - 1)), (N, N))
ans = shortest_path(matr, indices=0)[-1]
if ans == np.inf:
    ans = 0
print(int(ans) - 1)


### FIXED CODE ###

import sys
from collections import defaultdict
import networkx as nx

input = sys.stdin.buffer.readline

N, M = map(int, input().split())
LR_dict = defaultdict(lambda: 10 ** 9)
for _ in range(M):
    l, r, c = map(int, input().split())
    LR_dict[(l, r)] = min(LR_dict[(l, r)], c)

G = nx.DiGraph()
G.add_nodes_from(range(1, N + 1))
G.add_weighted_edges_from([(x + 1, x, 0) for x in range(1, N)])
G.add_weighted_edges_from((l, r, c) for (l, r), c in LR_dict.items())

try:
    print(nx.dijkstra_path_length(G, 1, N))
except nx.NetworkXNoPath:
    print(-1)
N = int(input())
A = list(map(int, input().split()))
bottom = sum(A)

if A[0] >= 2:
  print(-1)
  exit()

ret = 1
children = 1 - A[0]
bottom -= A[0]
 
for i in range(N):
    children = children * 2 - A[i+1]
    if children <= -1:
      ret = -1
      break
    
    bottom -= A[i+1]
    if children >= bottom:
      children = bottom
    ret += children + A[i+1]
print(ret)


### FIXED CODE ###

h1, m1, h2, m2, k=map(int, input().split())

print((h2-h1)*60+(m2-m1)-k)
import math

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

pits = []

cost = 0

for i in range(0, N+1):
    pits.append(i)

half = int(len(pits) / 2)


# 真ん中
if X == half:
    cost_r = 0
    cost_l = 0
    for a in A:
        # 右側
        if X < a:
            cost_r += 1
        # 左側
        if X > a:
            cost_l += 1
    cost = min(cost_l, cost_r)
# 右側
elif half < X:
    for a in A:
        if X < a:
            count += 1
# 左側
else:
    for a in A:
        if X > a:
            count += 1

print(cost)

### FIXED CODE ###

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

r_count = 0
l_count = 0

tmp_1 = X
tmp_2 = X


while tmp_1 != N:
    tmp_1 += 1
    if tmp_1 in A:
        r_count += 1

while tmp_2 != 0:
    tmp_2 -= 1
    if tmp_2 in A:
        l_count += 1


res = min(l_count, r_count)
print(res)
X,Y = map(int,input().split())
mod = 10**9+7
if (2*X-Y) % 3 != 0 or (2*Y-X) % 3 != 0:
    print(0)
    exit(0)
x,y = (2*Y-X)//3,(2*X-Y)//3
N = x+y
K = x
def pow(x, n, mod):
    ret = 1
    while n>0:
        if (n&1):
            ret = (ret*x) % mod
        x = (x*x) % mod
        n >>= 1
    return ret
fact = [None]*(N+1)
fact[0] = 1
for i in range(1, N+1):
    fact[i] = (fact[i-1]*i) % mod
finv = [None]*(N+1)
finv[-1] = pow(fact[-1], mod-2, mod)
for i in range(N, min(x,y)-1, -1):
    finv[i-1] = (finv[i]*i) %mod
def comb(n, k):
    return (fact[n]*finv[n-k]*finv[k]) % mod
print(comb(N,K))

### FIXED CODE ###

X,Y = map(int,input().split())
mod = 10**9+7
if (2*X-Y) % 3 != 0 or (2*Y-X) % 3 != 0:
    print(0)
    exit(0)
x,y = (2*Y-X)//3,(2*X-Y)//3
if x < 0 or y < 0:
    print(0)
    exit(0)
N = x+y
K = min(x,y)
def pow(x, n, mod):
    ret = 1
    while n>0:
        if (n&1):
            ret = (ret*x) % mod
        x = (x*x) % mod
        n >>= 1
    return ret
fact = [0]*(N+1)
fact[0] = 1
for i in range(1, N+1):
    fact[i] = (fact[i-1]*i) % mod
finv = [0]*(N+1)
finv[N] = pow(fact[N], mod-2, mod)
for i in range(N, 0, -1):
    finv[i-1] = (finv[i]*i) %mod
print((fact[x+y]*finv[x]*finv[y]) % mod)
S=input()
tmp=[]
for i in range(len(S)-2):
  tmp.append(S[i:i+2])
for j in range(len(S)-2):
  tmp[i]=abs(753-int(tmp[i]))
print(int(min(tmp)))

### FIXED CODE ###

S = input()
tmp = []
for i in range(len(S)-2):
    tmp.append(S[i:i+3])
for j in range(len(S)-2):
    tmp[j] = abs(753-int(tmp[j]))
print(min(tmp))
#!/usr/bin/env python3
import sys
import math

def main():
    N = int(input())
    digit = math.floor(math.log10(N))
    ans = [9 * digit]
    ans.append(sum([int(s) for s in str(N)]))
    
    for i in range(1, digit+1):
        tmp = [int(s) for s in str(N//(10**i) * 10**i - 1)]
        ans.append(sum(tmp))
    print(max(ans))


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
import math

def main():
    N = int(input())
    digit = int(math.log10(N))
    c = N // (10**digit)
    if N < int(str(c) + '9'*digit):
        print(9 * digit + c -1)
    else:
        print(9 * digit + c)

if __name__ == '__main__':
    main()
N = int(input())
print(sum(list(range(N))))

### FIXED CODE ###

N = int(input())
ans = N*(N-1)//2
print(ans)
a=input()
b=a.split()

num=[]

x1=[1]*int(b[0])
x2=[0]*int(b[1])
x3=[-1]*int(b[2])

num[len(num):len(num)]=x1
num[len(num):len(num)]=x2
num[len(num):len(num)]=x3

k=int(b[3])
print(sum(num[0:k]))


### FIXED CODE ###

a=input()
b=a.split()

x1=int(b[0]) #1
x2=int(b[1]) #0
x3=int(b[2]) #-1
x4=int(b[3]) #k

if x4 <= x1:
	print(x4)

elif x4 <= x1+x2:
	print(x1)

else:
	print(x1-(x4-x1-x2))
a ,b = map(int ,input().split())
if a%2=0 or b%2=0:
  print Even
else:
  print Odd


### FIXED CODE ###

a, b = map(int, input().split())
if (a*b) % 2:
    print("Odd")
else:
    print("Even")
import sys
input = sys.stdin.readline
N = int(input().strip())
C = [0] * (N - 1)
S = [0] * (N - 1)
F = [0] * (N - 1)
ans = [0] * (N)
for n in range(N-1):
    C, S, F = [int(x) for x in input().strip().split()]
    ans[n] = S + C
    for i in range(n):
        if ans[i] <= S:
            ans[i] = S + C
        elif ans[i] % F == 0:
            ans[i] += C
        else:
            ans[i] = (ans[i] // F + 1) * F + C

for a in ans:
    print(a)

### FIXED CODE ###

import sys
input = sys.stdin.readline
N = int(input().strip())
C = [0] * (N - 1)
ans = [0] * (N)
for n in range(N-1):
    C, S, F = [int(x) for x in input().strip().split()]
    ans[n] = S + C
    for i in range(n):
        if ans[i] <= S:
            ans[i] = S + C
        elif ans[i] % F == 0:
            ans[i] += C
        else:
            ans[i] = (ans[i] // F + 1) * F + C

for a in ans:
    print(a)
x,y = list(map(int,input().split()))

mod = 10**9 + 7

import math
def comb(n,r):
    return (math.factorial(n)//(math.factorial(n-r)*math.factorial(r)))

if (x+y)%3!=0:
    print(0)
    exit()
else:
    n = (2/3)*x - (1/3)*y
    m = (2/3)*y - (1/3)*x
    print(comb(n+m,m)%mod)
    exit()

### FIXED CODE ###

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

mod = 10**9 + 7

# import math
# def comb(n,r):
#     return (math.factorial(n)//(math.factorial(n-r)*math.factorial(r)))

# def comb(n, r, mod):
#     if ( r<0 or r>n ):
#         return 0
#     r = min(r, n-r)
#     return g1[n] * g2[r] * g2[n-r] % mod

def comb_mod(n, r, mod):
    if n < r:
        return 0
    elif n < 0 or r < 0:
        return 0
    else:
        fac = [1, 1]
        finv = [1, 1]
        inv = [0, 1]
        for i in range(2, n + 1):
            fac.append(fac[-1] * i % mod)
            inv.append(-inv[mod % i] * (mod // i) % mod)
            finv.append((finv[-1] * inv[-1]) % mod)
        return int(fac[n] * finv[r] * finv[n - r] % mod)


# def comb(n,r,mod):
# 	'''
# 	return nCr
# 	O(min{n-r, r})
# 	'''
# 	a=1
# 	b=1
# 	r = min(r,n-r)
# 	for i in range(r):
# 		a = a*(n-i)%mod
# 		b = b*(i+1)%mod
# 	return a*pow(b,mod-2,mod)%mod

if (x+y)%3!=0:
    print(0)
    exit()
else:
    m = int((2*x - y)/3)
    n = int((2*y - x)/3)
    if n>=0 and m>=0:
        print(comb_mod(n+m,n,mod))
        exit()
    else:
        print(0)
        exit()
def test():
    d,n = map(int,input().split())
    if d == 0:
        a = [i for i in range(1,n+1) if int(i/100)==0 or i%100 != 0]
        print(a[n])
    elif d == 1:
        a = [i for i in range(1,n+1) if int(i/100)==1]
        print(a[n])
    elif d == 2:
        a = [i for i in range(1,n+1) if int(i/100)==2]
        print(a[n])


if __name__ == "__main__":
    test()


### FIXED CODE ###

def test():
    d,n = map(int,input().split())
    if n == 100:
        n += 1
    print(100**d*n)


if __name__ == "__main__":
    test()
import math

r = input()
print(r ** 2 * math.pi, r * 2 * math.pi)


### FIXED CODE ###

import math

r = float(input())
print(float(r ** 2 * math.pi), float(r * 2 * math.pi))
a,b,c = map(int,input().split())
print(a+b+c-max(a+b+c))

### FIXED CODE ###

a,b,c = map(int,input().split())
print(a+b+c-max(a,b,c))
import math
def comb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

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

if n == k:
    print(1)
    for _ in range(k-1):
        print(0)
    
    exit()

for i in range(1,k+1):
    ans = comb(n - k + 1, i) * math.factorial(k - 1) // math.factorial(k-i) // math.factorial(i-1)
    print(ans % 1000000007)


### FIXED CODE ###

import math
def comb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

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

for i in range(1,k+1):
    if n - k + 1 >= i:
        ans = comb(n - k + 1, i) * math.factorial(k - 1) // math.factorial(k-i) // math.factorial(i-1)
        print(ans % 1000000007)
    else:
        print(0)
x = [[0]*50 for i in range(11)]
for i in range(0, 2**10):
    B = format(i,'b')[::-1]
    s,c,j = 0,0,0
    for e in B:
        if e=="1": s+=j; c+=1
        j　+=　1
    x[c][s]　+=　1

while 1:
    n,s = map(int, raw_input().split())
    if n==0 and s==0: break
    print 0 if s>=50 else x[n][s]

### FIXED CODE ###

x = [[0]*50 for i in range(11)]
for i in range(0, 2**10):
    B = format(i,'b')[::-1]
    s,c,j = 0,0,0
    for e in B:
        if e=="1": s,c = s+j, c+1
        j+= 1
    x[c][s]+=1

while 1:
    n, s=map(int, raw_input().split())
    if n==0 and s==0: break
    print 0 if s>=50 else x[n][s]
# start -> ダム -> 山 -> end で2部グラフを作って最大流を求めれば求まるはず


MAX_V = 100002
used = [False] * MAX_V
edge = [[] for _ in range(MAX_V)]

class Edge():

    def __init__(self, to, cap, rev):
        self.to = to
        self.cap = cap
        self.rev = rev

def init_used():
    for i in range(MAX_V):
        used[i] = False

def read():
    N = int(input().strip())
    A = list(map(int, input().strip().split()))
    return N, A

def build_graph(N, A, INF=10000000000):
    START = 2 * N
    END = 2 * N + 1
    for i in range(N):
        edge[START].append(Edge(i, A[i], len(edge[i])))
        edge[i].append(Edge(START, 0, len(edge[START])))
    for i in range(N):
        j = N + ((i - 1) % N)
        edge[i].append(Edge(N+i, INF, len(edge[N+i])))
        edge[j].append(Edge(N + j, INF, len(edge[N + j])))
        edge[N+i].append(Edge(N + i, 0, len(edge[i])))
        edge[N+j].append(Edge(N + j, 0, len(edge[j])))
    for i in range(N):
        edge[N+i].append(Edge(END, INF, len(edge[END])))
        edge[END].append(Edge(N+i, 0, len(edge[N+i])))
    return edge, START, END


def dfs(edge, weight, v, t, f=10000000000):
    if v == t:
        return f
    used[v] = True
    for i in range(len(edge[v])):
        to = edge[v][i]
        if not used[to] and weight[v][i] > 0:
            d = dfs(to, t, min(f, weight[v][i]))
            if d > 0:
                weight[v][i] -= d
                edge[v]


def maximum_flow(edge, s, t):
    V = len(edge)
    while True:
        init_used()
        d = dfs(edge, s, t)
        return 0
    

def solve(N, A):
    # 0~N-1: damu, N~2N-1: yama, 2N: s, 2N+1: t
    edge, START, END = build_graph(N, A)
    maximum_flow(edge, START, END)
    return 0


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))


### FIXED CODE ###

def read():
    N = int(input().strip())
    A = list(map(int, input().strip().split()))
    return N, A

def solve(N, A):
    x = [0 for i in range(N)]
    x[0] = sum([A[i]*(-1)**i for i in range(0, N)]) // 2
    for i in range(0, N-1):
        x[i+1] = A[i] - x[i]
    x = [2 * x[i] for i in range(N)]
    return ' '.join(map(str, x))

if __name__ == '__main__':
    inputs = read()
    print("%s" % solve(*inputs))
N = int(input())
plan = []

for j in range(0,N):
    t,x,y = map(int,input().split())
    plan.append(t,x,y)

if (plan[0] < plan[1] + plan[2]) or ((plan[0] % 2) != ((plan[1] + plan[2]) % 2)):
    print("No")
    exit()

for i in range(0,N-1):
    time_dis = plan[i*3 +3] - plan[i*3]
    x_dis = abs(plan[i*3+1] - plan[i*3+1 +3])
    y_dis = abs(plan[i*3+2] - plan[i*3+2 +3])
    
    if (time_dis < x_dis + y_dis) or ((time_dis % 2) != ((x_dis + y_dis) % 2)):
        print("No")
        exit()
        
print("Yes")


### FIXED CODE ###

N = int(input())
plan = []

for j in range(0,N):
    t,x,y = map(int,input().split())
    plan.append(t)
    plan.append(x)
    plan.append(y)

if (plan[0] < plan[1] + plan[2]) or ((plan[0] % 2) != ((plan[1] + plan[2]) % 2)):
    print("No")
    exit()

for i in range(0,N-1):
    time_dis = plan[i*3 +3] - plan[i*3]
    x_dis = abs(plan[i*3+1] - plan[i*3+1 +3])
    y_dis = abs(plan[i*3+2] - plan[i*3+2 +3])
    
    if (time_dis < x_dis + y_dis) or ((time_dis % 2) != ((x_dis + y_dis) % 2)):
        print("No")
        exit()
        
print("Yes")
N,K = map(int, input().split())
h = list(map(int, input().split()))
h.sort(reverse=True)
a=0:
for i in h:
  if i>=K:
    a+=1
  else:
    break
print(a)

### FIXED CODE ###

N,K = map(int, input().split())
h = list(map(int, input().split()))
h.sort(reverse=True)
a=0
for i in h:
  if i>=K:
    a+=1
  else:
    break
print(a)
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

k = inp()
s = input()
lf len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")

### FIXED CODE ###

#dt = {} for i in x: dt[i] = dt.get(i,0)+1
#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}
ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

k = inp()
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")
n,x = map(int, input().split())
l = list(map(int, input().split()))

s = 0
t = 0
for i in range(n+1):
  t += l[i]
  s += 1
  if t >= x:
    break
print(s)

### FIXED CODE ###

n,x = map(int, input().split())
l = list(map(int, input().split()))

s = 1
d = 0
for i in l:
  d += i
  if d <= x:
    s += 1
print(s)
N = int(input())
A = list(map(int,input().split()))
if (0 in A):
    print(0)
for i in range(N):
    output = 1
    output *= a[i]
    if output> 10**18:
        print(-1)
        quit()
print(output)

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
output = 1
if 0 in A:
    print(0)
else:
    for i in range(N):
        output *= A[i]
        if output> 10**18:
            print(-1)
            quit()
    print(output)
import copy

def discomfort(dic, n):
    global expenses
    if expenses != None and sum(p_res) >= expenses:
        return
    if n == s_n and g_n in load:
        expenses = sum(p_res)
        Pirates.append(r-(sum(p_res)+p))
        return
    for v in dic[n]:
        p_res.append(p_dic[(n,v)])
        c_l_dic = copy.deepcopy(dic)
        c_l_dic[n].remove(v)
        c_l_dic[v].remove(n)
        load.append(v)
        discomfort(c_l_dic, v)
        del p_res[-1]
        del load[-1]

if __name__ == '__main__':
    l_dic = {}
    p_dic = {}
    for line in open('s.txt').readlines():
        n1, n2, p1, p2 = map(int, line.rstrip().split(','))
        if not n1 in l_dic:
            l_dic[n1] = [n2]
            if not n2 in l_dic:
                l_dic[n2] = [n1]
            else:
                l_dic[n2].append(n1)
        else:
            l_dic[n1].append(n2)
            if not n2 in l_dic:
                l_dic[n2] = [n1]
            else:
                l_dic[n2].append(n1)
        p_dic[(n1,n2)] = p1
        p_dic[(n2,n1)] = p2
    
    s_n, g_n, r, p = map(int, raw_input().split(','))
    p_res = []
    load = [2]
    expenses = None
    Pirates = []
    discomfort(l_dic, s_n)
    print sorted(Pirates)[-1]

### FIXED CODE ###

import copy

def discomfort(dic, n):
    global Pirates, expenses, c
    if expenses != None and sum(p_res) >= expenses:
        return
    if n == c:
        if n == g_n:
            c = s_n
            discomfort(l_dic, g_n)
            c = g_n
            return
        else:
            expenses = sum(p_res)
            Pirates = r-(sum(p_res)+p)
            return
    for v in dic[n]:
        c_l_dic = copy.deepcopy(dic)
        c_l_dic[n].remove(v)
        c_l_dic[v].remove(n)
        p_res.append(p_dic[(n,v)])
        load.append(v)
        discomfort(c_l_dic, v)
        del p_res[-1]
        del load[-1]

if __name__ == '__main__':
    t_c = int(raw_input())
    
    l_dic = {}
    p_dic = {}
    for i in range(input()):
        n1, n2, p1, p2 = map(int, raw_input().split(','))
        if not n1 in l_dic:
            l_dic[n1] = [n2]
            if not n2 in l_dic:
                l_dic[n2] = [n1]
            else:
                l_dic[n2].append(n1)
        else:
            l_dic[n1].append(n2)
            if not n2 in l_dic:
                l_dic[n2] = [n1]
            else:
                l_dic[n2].append(n1)
        p_dic[(n1,n2)] = p1
        p_dic[(n2,n1)] = p2
    
    s_n, g_n, r, p = map(int, raw_input().split(','))
    c = g_n
    Pirates = 0
    p_res = []
    load = [s_n]
    expenses = None
    discomfort(l_dic, s_n)
    print Pirates
X = int(input())

if 400 <= X < 600:
    result = 8
elif X < 800:
    result = 7
elif X < 1000:
    result = 6
elif X < 1200:
    result = 5
elif X < 1400:
    result = 4
elif X < 1600:
    result = 3
elif X < 1800:
    result = 2
elif X < 200:
    result = 1

print(result)


### FIXED CODE ###

X = int(input())
 
if 400 <= X < 600:
    result = 8
elif X < 800:
    result = 7
elif X < 1000:
    result = 6
elif X < 1200:
    result = 5
elif X < 1400:
    result = 4
elif X < 1600:
    result = 3
elif X < 1800:
    result = 2
elif X < 2000:
    result = 1
 
print(result)