Harryxun/stf_run huggingface dataset:
import numpy as np

H, W = map(int, raw_input().split())
arr=np.array([])
s=0
while s != H:
  li=list(raw_input())
  li=np.array(li)
  arr=np.hstack((arr,li))

  s+=1
arr=arr.reshape((H,W))
count=0

def check(x,y):
    import __main__
    if arr[x,y] == "#":
        __main__.count+=1

for x in range(H):
    stri=""
    for y in range(W):
        if arr[x,y] == ".":
            count=0
            top= None
            right =None
            left=None
            if y != 0:
                top=True
                check(x,(y-1))
            if x != 0:
                if top:
                    check((x-1),(y-1))
                check((x-1),y)
                left=True
            if x != (W-1):
                if top:
                    check((x+1),(y-1))
                right=True
                check((x+1),y)
            if y != (H-1):
                if left:
                    check(x-1,y+1)
                if right:
                    check(x+1,y+1)
                check(x,(y+1))
            stri=stri+str(count)
        else:
            stri=stri+"#"
    print(stri)


### FIXED CODE ###

a ,b ,c=map(int,raw_input().split())
if a==b:
  print(c)
elif a==c:
  print(b)
else:
  print(a)
n,k=map(int,input().split())
h=sorted([int(input()) for _ in range(n)])
a=10**9
for i in range(n-k+1):
    a1=h1[i+k-1]-h[i]
    a=min(a,a1)
print(a)

### FIXED CODE ###

n,k=map(int,input().split())
h=sorted([int(input()) for _ in range(n)])
a=10**9
for i in range(n-k+1):
    a1=h[i+k-1]-h[i]
    a=min(a,a1)
print(a)
N=int(input())

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

B=[[0]*N]
for i in range(N):
  B[A[i]]=i

for i in range(N);
	print(B[i],end=" ")
       

### FIXED CODE ###

N=int(input())

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

B=[0]*N
for i in range(N):
  B[A[i]-1]=i+1

for i in range(N):
	print(B[i],end=" ")
a,b = map(int,input().split())
c,d = map(int,input().split())
e = int(input())

f = a + (b*e)
g = c + (d*e)

if f > g:
	print("YES")
else:
	print("NO")

### FIXED CODE ###

a = str(input())
print(a[0:3])
def f(x):
	global hashi
	if(x in hashi):
		return hashi[x]
	if(adj[x]==[]):
		return 0
	mino=0
	for i in adj[x]:
		mino=max(mino,f(i))
	hashi[x]=mino+1
	return mino+1
l=input().split()
n=int(l[0])
m=int(l[1])
adj=[[] for i in range(n+1)]
for i in range(m):
	l=input().split()
	u=int(l[0])
	v=int(l[1])
	adj[u].append(v)
maxa=0
hashi=dict()
for i in range(1,n+1):
	maxa=max(maxa,f(i))
print(maxa)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
def f(x):
	global hashi
	if(x in hashi):
		return hashi[x]
	if(adj[x]==[]):
		return 0
	mino=0
	for i in adj[x]:
		mino=max(mino,f(i))
	hashi[x]=mino+1
	return mino+1
l=input().split()
n=int(l[0])
m=int(l[1])
adj=[[] for i in range(n+1)]
for i in range(m):
	l=input().split()
	u=int(l[0])
	v=int(l[1])
	adj[u].append(v)
maxa=0
hashi=dict()
for i in range(1,n+1):
	maxa=max(maxa,f(i))
print(maxa)
n = input()
a = list(int, input().split()))

print(0)
for i in range(len(a)):
    print(a.count(i))


### FIXED CODE ###

num = int(input())
h_numbers = list(map(int, input().split()))
s = [0] * num
for i in h_numbers:
    s[i-1] += 1
[print(i) for i in s]
n = int(input())
if(x >= 30):
  print('Yes')
else:
  print('No')

### FIXED CODE ###

n = int(input())
if(n >= 30):
  print('Yes')
else:
  print('No')
import math
A,B=map(int,input().split())
if(math.log2(A)%1!=0):#少数ならば？
    m=int(math.log2(A))+1
else:
    m=int(math.log2(A))

n=int(math.log2(B))

binary=0
if m>=n:
    for x in range(A,B+1):
        binary = x^binary
        
    print(binary)
    exit()
else:
    for x in range(A,2**m):
        binary = binary^x

    for x in range(2**n,B+1,1):
        binary = binary^x

print(binary)


### FIXED CODE ###

import math
A,B=map(int,input().split())
x=0
if A%2==0:#偶数スタート
    if(B%2==0):#偶数エンド
        if((B-A)/2 %2 == 0 ):#1が偶数個ならば？
            print(B)
        else:
            print(1^B)
    else:#奇数エンド
        if(((B+1) - A)/2 %2 == 0):#1が偶数個ならば？
            print(0)
        else:
            print(1)
else:#奇数スタート
    if(B%2==0):#偶数エンド
        if((B-(A+1))/2 %2 ==0):
            print(A^B)
        else:
            print(A^B^1)
    else:#奇数エンド
        if((B-A)/2 %2 == 0):
            print(A)
        else:
            print(A^1)
import sys
input = sys.stdin.readline


def main():
    n, q = map(int, input().split())
    #n, q = map(int, "4 3".split())
    g = [[] for _ in range(n)]
    for i in range(n-1):
        a, b = map(int, input().split())
        #a, b = map(int, ["1 2", "2 3", "2 4"][i].split())
        g[a-1].append(b-1)

    ans = [0] * n
    def dfs(start, point):
        stack = [start]
        while stack:
            x = stack.pop()
            ans[x] += point
            stack += g[x]

    for i in range(q):
        p, v = map(int, input().split())
        #p, v = map(int, ["2 10", "1 100", "3 1"][i].split())
        dfs(p-1, v)

print(' '.join(map(str, ans)))

if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys

def main():
    sys.setrecursionlimit(10**6)
    input = sys.stdin.readline
    n, q = map(int, input().split())
    #n, q = map(int, "4 3".split())
    g = [[] for _ in range(n)]
    for i in range(n-1):
        a, b = map(int, input().split())
        #a, b = map(int, ["1 2", "2 3", "2 4"][i].split())
        g[a-1].append(b-1)
        g[b-1].append(a-1)


    add = [0] * n
    for i in range(q):
        p, v = map(int, input().split())
        #p, v = map(int, ["2 10", "1 100", "3 1"][i].split())
        #dfs(p-1, v)
        add[p-1] += v

    ans = [0] * n
    def dfs(v,p,value): #p: parent of v
        value += add[v]
        ans[v] = value
        for c in g[v]:
            if c == p: continue
            dfs(c,v,value)
    dfs(0, -1, 0)
    """
    def dfs(start, point):
        stack = [start]
        while stack:
            x = stack.pop()
            ans[x] += point
            stack += g[x]
    """

    print(' '.join(map(str, ans)))

if __name__ == '__main__':
    main()
import sys
input = sys.stdin.readline

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

answer = None
for i in B:
    answer = min(answer, len(bin(i)) - bin(i).rfind("1") - 1)
print(answer)


### FIXED CODE ###

import sys
input = sys.stdin.readline

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

answer = float("inf")
for i in B:
    answer = min(answer, len(bin(i)) - bin(i).rfind("1") - 1)
print(answer)
import sys
input = sys.stdin.readline
n,m = map(int,input().split())

from fractions import gcd
a = gcd(n,m)

import numpy as np

def seachPrimeNum(N):
    max = int(np.sqrt(N))
    seachList = [i for i in range(2,N+1)]
    primeNum = []
    while seachList[0] <= max:
        primeNum.append(seachList[0])
        tmp = seachList[0]
        seachList = [i for i in seachList if i % tmp != 0]
    primeNum.extend(seachList)
    return primeNum

t = seachPrimeNum(10*8)
for item in t:
    if a % item == 0:
        c += 1

print(c)

### FIXED CODE ###

import sys
input = sys.stdin.readline
n,m = map(int,input().split())

from fractions import gcd
a = gcd(n,m)

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

t = factorization(a) 

if (n == 1) or (m == 1):
    print(1)
else:
    print(len(t)+1)
import collections
_=int(input())
l = list(map(int, input().split()))
c = collections.Counter(l)
M={}

for i,v in c.items():
    if v>1:
        M[i] =  v*(v-1)/2

for k in l:
    M_ = M.copy()
    M_[k] =  M_[k]*(c[k]-2)/c[k]
    print(sum(M_.values()))

### FIXED CODE ###

import collections
_ = int(input())
l = list(map(int, input().split()))
c = collections.Counter(l)
M=0
for v in c.values():
    if v>1:
        M +=  v*(v-1)/2

for k in l:
    print(int(M-c[k]+1))
a=map(int,raw_input().split())

s=a[0]+a[1]

if s>10 :
    print("error")
else :
    print(s)



### FIXED CODE ###


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

s=a+b


if s>=10 :
    print("error")
else :
    print(s)
#!/usr/bin/env python3
n, *a = map(int, open(0))
n = n//2 - 1;a.sort()
print(2*sum(a[n+2:]) - 2*sum(a[:n]) + a[n+1] - a[n] - [0, min(a[n]+a[n+2], 2*a[n+1])][n%2])

### FIXED CODE ###

#!/usr/bin/env python3
N, *a = map(int, open(0))
n = N//2 - 1
a.sort()
print(2*sum(a[n+2:]) - 2*sum(a[:n]) + a[n+1] - a[n] - (min(a[n]+a[n+2], 2*a[n+1]) if N%2 else 0))
n = int(input())
sl = []
for _ in range(n):
    sl.append(input())
rl=[]
ll=[]
rslt=0
for i in range(n):
    r=sorted(sl[i])
    if r in rl: ll[rl.index(r)]+=1; rslt+=ll[rl.index(r)]
    else: rl.append(r); ll.append(0)
print(rslt)


### FIXED CODE ###

a,b = map(int, input().split())
r=[a+b, a-b, a*b]
print(max(r))
#入力:N,M(int:整数)
def input2():
	return map(int,input().split())
  
n=int(input())
A=input_array()
MAX=10**18
ans=A[0]

for i in range(1,len(A)):
	ans*=A[i]
	if ans==0:
		break
	elif ans>MAX:
		ans=-1
		break
	else:
		pass

print(ans)

### FIXED CODE ###

import sys

#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))
  
n=input1()
A=input_array()
if 0 in A:
	print(0)
	sys.exit()
ans=1

for a in A:
	ans=ans*a
	if ans > 10**18:
		break

if ans > 10**18:
	print(-1)
else:
	print(ans)
s = input()
print(input().count('1'))

### FIXED CODE ###

s = input()
print(s.count('1'))
a, b = (int(i) for i in input().split())

common_divisor_set = []
result_set = []

GCD = lambda a, b: (GCD(b, a % b) if a % b else b)

for i in range(min(a, b), 0, -1):
    if a%i == 0 and b%i == 0:
        common_divisor_set.insert(0, i)

left = [0 for x in range(n)]
right = [0 for x in range(n)]
ans = -1

n = len(common_divisor_set)
for i in range(n):
    if (i == 0):
        gcd = a[0]
    else:
        gcd = GCD(a[i], left[i - 1])
    left[i] = gcd

for i in range(n-2, -1, -1):   
    if (i == n - 1):
        gcd = a[n - 1]
    else:
        gcd = GCD(a[i], right[i + 1])
    right[i] = gcd

for i in range(n):
    if (i == 0):
        gcd = right[1]
    elif (i == n - 1):
        gcd = left[n - 2]
    else:
        gcd = GCD(left[i - 1], right[i + 1])
    if (gcd>ans):
        ans = gcd

print(ans)


### FIXED CODE ###

from math import sqrt
a, b = (int(i) for i in input().split())

GCD = lambda x, y: (GCD(y, x % y) if x % y else y)
ab_gcd = GCD(a, b)

def factoring(gcb,n=2):
    for i in range(n,int(gcb**0.5)+1):
        if gcb%i==0:
            ret = factoring(gcb//i,i)
            ret[i] = ret.get(i,0)+1
            return ret
    return {gcb:1}

result = set(factoring(ab_gcd).keys())
result.add(1)
print(len(result))
S = raw.input()
S = S.replace("2017","2018")

print(S)


### FIXED CODE ###

S = input()
S=S.replace("2017","2018")

print(S)
a,b=input().split()
a=int(a)
b=Decimal(b)
print(int(a*b))

### FIXED CODE ###

from decimal import *
a,b=input().split()
a=int(a)
b=Decimal(b)
print(int(a*b))
import sys
from collections import Counter

read = sys.stdin.read

N, *S = map(str, read().split())
s = Counter(S)
n = max(s.values())
answer = [i for i, j in s if j == n]
answer.sort()
print('\n'.join(answer))


### FIXED CODE ###

import sys
from collections import Counter

read = sys.stdin.read

N, *S = map(str, read().split())
s = Counter(S).most_common()
n = s[0][1]
answer = [i for i, j in s if j == n]
answer.sort()
print('\n'.join(answer))
from math import ceil
def fanc(x):
    return round((ceil(x/10))*10)
menu = [int(input()) for _ in range(5)]
menu.sort(key=lambda x:x%10)
for i in range(5):
    if menu[i]%10:
        ans = menu.pop(i)
        break
menu = list(map(fanc, menu))
print(ans+sum(menu))

### FIXED CODE ###

from math import ceil
def fanc(x):
    return int((ceil(x/10))*10)
ans = 0
menu = [int(input()) for _ in range(5)]
menu.sort(key=lambda x:x%10)
for i in range(5):
    if menu[i]%10:
        ans += menu.pop(i)
        break
menu = list(map(fanc, menu))
print(ans+sum(menu))
import math

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

point = []
for _ in range(n):
  x = list(map(int, input().split()))
  point.append(x)

cnt = 0
for i in range(n-1):
  for j in range(i+1, n):
    dist = 0
    for d in range(D):
      dist += (point[i][d] - point[j][d])**2
    dist = math.sqrt(dist)
    if int(dist) == dist:
      cnt += 1
print(cnt)

### FIXED CODE ###

N, A, B = map(int, input().split())
print(min(A*N, B))
def resolve():
    n, k = map(int, input().split())
    h = list(map(int, input().split()))
    i = sorted(h, reverse=True)

    if k==0:
        print(sum(i))
        exit()
    else:
        j = i[k:]
        print(sum(j))
resolve()

### FIXED CODE ###

def resolve():
    import math
    h = int(input())
    logh = int(math.log(h,2))
    rlist = []
    cum = 1
    for i in range(40):
        rlist.append(cum)
        cum = cum*2+1
    print(rlist[logh])
resolve()
N = int(input())
a = [0] + [int(input()) for _ in range(N)]
x = 1
visited = set([1])
answer = 0

while True:
  x = a[x]
  if x in visited:
    answer = -1
    break
  visited.add(x)
  answer += 1
  if x == 2:
    break
    
print(answer)


### FIXED CODE ###

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

if a[1] >= a[2]:
  print("delicious")
else:
  if a[2] - a[1] <= a[0]:
    print("safe")
  else:
    print("dangerous")
n = input()
ns = n % 2
if n == 1:
    print(float(1)
elif ns == 0:
    print(float(0.5))
else:
    print(float(n//2+1))

### FIXED CODE ###

n = int(input())
ns = n % 2
if n == 1:
    print(1)
elif ns == 0:
    print(0.5)
else:
    print(((n//2)+1)/n)
N = int(input())
S = [input() for _ in range(N)]
M = int(input())
T = [input() for _ in range(M)]

pnt = []

for b in blue:
    if b in red:
        pnt.append(blue[b] - red[b])
    else:
        pnt.append(blue[b])
        
print(max(pnt) if max(pnt) > 0 else 0)

### FIXED CODE ###

N = int(input())
S = [input() for _ in range(N)]
M = int(input())
T = [input() for _ in range(M)]

from collections import Counter

blue = Counter(S)
red = Counter(T)

point = []

for bkey in blue:
    if bkey in red:
        point.append(blue[bkey] - red[bkey])
    else:
        point.append(blue[bkey])
        
print(max(point) if max(point) > 0 else 0)
import sys
sys.getrecursionlimit(1000000)

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

G = [[] for i in range(N)]
for _ in range(M):
    Ai, Bi = map(int, input().split())
    G[Ai - 1].append(Bi - 1)
    G[Bi - 1].append(Ai - 1)

color = [0] * N
def dfs(v, c):
    '''
    頂点vをcで塗る　そこから深さ優先探索で交互に塗っていく
    '''
    color[v] = c
    for i in G[v]:
        if color[i] == c:
            return False
        if color[i] == 0 and not(dfs(i, -c)):
            return False
    return True

if dfs(0, 1):
    print(color.count(1) * color.count(-1) - M)
else:
    print(N * (N - 1) // 2 - M)


### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)

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

G = [[] for i in range(N)]
for _ in range(M):
    Ai, Bi = map(int, input().split())
    G[Ai - 1].append(Bi - 1)
    G[Bi - 1].append(Ai - 1)

color = [0] * N
def dfs(v, c):
    '''
    頂点vをcで塗る　そこから深さ優先探索で交互に塗っていく
    '''
    color[v] = c
    for i in G[v]:
        if color[i] == c:
            return False
        if color[i] == 0 and not(dfs(i, -c)):
            return False
    return True

if dfs(0, 1):
    print(color.count(1) * color.count(-1) - M)
else:
    print(N * (N - 1) // 2 - M)
n=int(input())

#データを並び替える
rowdata=[int(i) for i in input().split()]
rowdata.sort()

#nが偶数の時
if n%2==0:
    check=[]
    for i in range(1,n,2):
        check.append(i)
        check.append(i)
    if check==rowdata:
        print(int(2**(n/2))%1000000007)
    else:
        print(0)
        
#nが奇数の時
else:
    check=[]
    if n==1:
        check=[0]
    else:
        for i in range(0,n,2):
            if i==0:
                check.append(i)
            else:
                check.append(i)
                check.append(i)
    if check==rowdata:
        print(int(2**((n-1)/2))%1000000007)
    else:
        print(0)

        

### FIXED CODE ###

n=int(input())

#データを並び替える
rowdata=[int(i) for i in input().split()]
rowdata.sort()

#nが偶数の時
if n%2==0:
    check=[]
    a=1
    for i in range(1,n,2):
        check.append(i)
        check.append(i)
    if check==rowdata:
        for i in range(int(n/2)):
            a*=2
            a=a%1000000007
        print(a)
    else:
        print(0)
        
#nが奇数の時
else:
    check=[]
    a=1
    if n==1:
        check=[0]
    else:
        for i in range(0,n,2):
            if i==0:
                check.append(i)
            else:
                check.append(i)
                check.append(i)
    if check==rowdata:
        for i in range(int((n-1)/2)):
            a*=2
            a=a%1000000007
        print(a)
    else:
        print(0)
N, K = map(int, input().split())
h = list(map(int, input().split()))

count = 0
for i in range(N):
  if h[i] >= K:
    count += 1
print(count)

### FIXED CODE ###

N = int(input())

if N % 2 == 0:
  print(0.5)
else:
  print((N//2+1) / N)
def dps(v, p, links):
    lv = links[v]
    if not lv:
        return 0
    cnt0 = 0
    ret = 0
    for l in lv:
        if l == p:
            continue
        res = dps(l, v, links)
        ret += res
        if res == 0:
            cnt0 += 1
    if cnt0:
        ret += cnt0 - 1
    return ret


def solve(n, links):
    if n == 2:
        return 1
    for i, l in enumerate(links):
        if len(l) > 1:
            return dps(i, None, links)


n = int(input())
links = [set() for _ in range(n)]
for _ in range(n - 1):
    a, b = map(int, input().split())
    links[a].add(b)
    links[b].add(a)
print(solve(n, links))


### FIXED CODE ###

import sys

sys.setrecursionlimit(100000)


def dfs(v, p, links):
    lv = links[v]
    if len(lv) == 1:
        return 0
    cnt0 = 0
    ret = 0
    for l in lv:
        if l == p:
            continue
        res = dfs(l, v, links)
        ret += res
        if res == 0:
            cnt0 += 1
    if cnt0:
        ret += cnt0 - 1
    return ret


def solve(n, links):
    if n == 2:
        return 1
    for i, l in enumerate(links):
        if len(l) > 2:
            return dfs(i, None, links)
    else:
        return 1


n = int(input())
links = [set() for _ in range(n)]
for _ in range(n - 1):
    a, b = map(int, input().split())
    links[a].add(b)
    links[b].add(a)
print(solve(n, links))
sd = input()
T = input()

for i in range(len(sd)-len(T),-1,-1):
#    print(i)
    st=sd[i:len(T)+i]
#    print(sd[i:len(T)+i])
    fl=True
    for j in range(len(T)):
        if st[j]!='?':
            if st[j]!=T[j]:
                fl=False
    if fl:
        s=sd[:i]+T+sd[len(T)+i:]
        for k in range(len(s)):
            if s[k]=='?':
                s=s[:k]+'a'+s[k+1:]
        break
if fl:
    print(s)
else:
    print('UNRESTORABLE')

### FIXED CODE ###

sd = input()
T = input()

if len(sd)<len(T):
    fl=False
else:
    for i in range(len(sd)-len(T),-1,-1):
    #    print(i)
        st=sd[i:len(T)+i]
    #    print(sd[i:len(T)+i])
        fl=True
        for j in range(len(T)):
            if st[j]!='?':
                if st[j]!=T[j]:
                    fl=False
        if fl:
            s=sd[:i]+T+sd[len(T)+i:]
            for k in range(len(s)):
                if s[k]=='?':
                    s=s[:k]+'a'+s[k+1:]
            break
if fl:
    print(s)
else:
    print('UNRESTORABLE')
N, Q = map(int, input().split())
tree = [[] for i in range(N)]
for i in range(N-1):
    ai, bi = map(int, input().split())
    ai -= 1
    bi -= 1
    tree[ai].append(bi)
point = [0] * N
for j in range(Q):
    pi, xi = map(int, input().split())
    pi -= 1
    point[pi] = point[pi] + xi

# print(tree)
# print(point)

answer = [0] * N
def dfs(node, p):
    answer[node] = p + point[node]
    for t in tree[node]:
        dfs(t, answer[node])
    return None

dfs(0, 0)
print(' '.join(map(str,answer)))

### FIXED CODE ###

N, Q = map(int, input().split())
tree = [[] for i in range(N)]
for i in range(N-1):
    ai, bi = map(int, input().split())
    ai -= 1
    bi -= 1
    tree[ai].append(bi)
point = [0] * N
for j in range(Q):
    pi, xi = map(int, input().split())
    pi -= 1
    point[pi] += xi

answer = [0] * N
queue = []
counter = 0
queue.append((0, 0))
while True:
    if counter == len(queue):
        break
    node, p = queue[counter]
    counter += 1


    answer[node] = p + point[node]
    for t in tree[node]:
        queue.append((t, answer[node]))

print(' '.join(map(str,answer)))
# coding: UTF-8
num = (raw_input("")).split("")
if (num[0] * num[1]) == 15:
    print "*"
el if (num[0] + num[1]) == 15:
    print "+"
else:
    print "x"


### FIXED CODE ###

# coding: UTF-8
num = (raw_input("")).split()
x = (int(num[0]) * int(num[1]))
y = (int(num[0]) + int(num[1]))
if x == 15:
    print "*"
elif y == 15:
    print "+"
else:
    print "x"
n = int(input())

difs = {}
points = []

for i in range(n):
    x, y = list(map(int, input().split()))

    for j in range(len(points)):
        dif1 = (points[j][0] - x, points[j][1] - y)
        dif2 = (-dif1[0], -dif1[1])

        difs[dif1] = 1 if dif1 not in difs else difs[dif1] + 1
        difs[dif2] = 1 if dif2 not in difs else difs[dif2] + 1

    points.append((x, y))

print(n-max(difs.values()))

### FIXED CODE ###

n = int(input())

difs = {}
points = []

for i in range(n):
    x, y = list(map(int, input().split()))

    for j in range(len(points)):
        dif1 = (points[j][0] - x, points[j][1] - y)
        dif2 = (-dif1[0], -dif1[1])

        difs[dif1] = 1 if dif1 not in difs else difs[dif1] + 1
        difs[dif2] = 1 if dif2 not in difs else difs[dif2] + 1

    points.append((x, y))

if n == 1:
    print(1)
else:
    print(n-max(difs.values()))
def gcd(num1,num2):#ユークリッド互除法を関数化
    if num2 == 0:
        return num1
    return gcd(num2,num1%num2)

n = int(input())
t = [int(x) for x in input()]
time = 1

for i in t:#最大公約数を求める。　積を最小公倍数で割ればよい
    time = time * t // gcd(time,i)

### FIXED CODE ###

n = int(input())
ans = int(input())
 
def gcd(a,b):
    while b:
        a,b = b,a%b
    return a
 
def lcm(x,y):
    return (x*y//gcd(x,y))
 
for i in range(n-1):
    t = int(input())
    ans = lcm(ans,t)
print(ans)
i = 0

while True:
 i += 1
 x = raw_input()
 if x == "0":
  break:
 print "case %d: %s" % (i, x)

### FIXED CODE ###

 

import sys
for i,ws in enumerate(sys.stdin, 1):
    w = ws[:-1]
    if w =='0': break
    print 'Case %d: %s' % (i, w)
n = int(raw_input())
A = map(int,raw_input().split())
S = 0
inv = [1,-1]*(n//2) + [1]
for q in range(n):
  S += A[q]*inv1[q]
ans = [0]*n
for q in range(n):
  ans[q] = S
  S = 2*A[q]-S
print ' '.join(map(str, ans))


### FIXED CODE ###

n = int(raw_input())
A = map(int,raw_input().split())
S = 0
inv = [1,-1]*(n//2) + [1]
for q in range(n):
  S += A[q]*inv[q]
ans = [0]*n
for q in range(n):
  ans[q] = S
  S = 2*A[q]-S
print ' '.join(map(str, ans))
import math
r=int(input())
print(('%0.5f' % (math.pi*r**2)) + " " + ('%0.5f' % (2*math.pi*r)))

### FIXED CODE ###

import math
r = float(input())
print(('%0.5f' % (math.pi*r**2)) + " " + ('%0.5f' % (2*math.pi*r)))
S = list(map(int, input()))
ans = 0
l = len(S)
i = 0
while len(S)-1 > i:
    if S[i] != S[i+1]:
        S.pop(i)
        S.pop(i)
        ans += 2
        i -= 2
    i += 1


print(ans)

### FIXED CODE ###

S = list(map(int, input()))
ans = 0
l = len(S)
i = 0
while len(S)-1 > i:
    if S[i] != S[i+1]:
        S.pop(i)
        S.pop(i)
        ans += 2
        if i == 0:
            i -= 1
        else:
            i -= 2
    i += 1


print(ans)
for a in range(1, 10):
    for b in range(1, 10):
        if a * b == N:
            print('yes')
        else:
            print('No')

### FIXED CODE ###

N = int(input())
for a in range(1, 10):
    flag = False
    for b in range(1, 10):
        if a * b == N:

            flag = True
            break
    if flag:
        break
if flag:
    print('Yes')
else:
    print('No')