Harryxun/stf_run huggingface dataset:
from collections import Counter
N = int(input())
XY = []
XY_cand = []
for _ in range(N):
        x, y = map(int, input().split())
        XY.append((x,y))
for (x, y) in XY:
        for (i, j) in XY:
                if i != x or j != y:
                        XY_cand.append((i-x, j-y))
print(N - Counter(XY_cand).most_common()[0][1])

### FIXED CODE ###

from collections import Counter
N = int(input())
XY = []
XY_cand = []
for _ in range(N):
        x, y = map(int, input().split())
        XY.append((x,y))
for (x, y) in XY:
        for (i, j) in XY:
                if i != x or j != y:
                        XY_cand.append((i-x, j-y))
if XY_cand == []:
        print(N)
else:
        print(N - Counter(XY_cand).most_common()[0][1])
from sys import stdin
lines = stdin.readlines()
 
C = lines[0]

print(chr(ord(C) + 1))

### FIXED CODE ###


C = str(input())

print(chr(ord(C) + 1))
# -*- coding: utf-8 -*-
import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import numpy as np
import statistics
from statistics import mean, median,variance,stdev
import math

def main():
	A,B,C,X,Y = map(int, input().split(" "))
	
	if C >= A and C >= B:
		
		print(A*X + B*Y)
		sys.exit()
	
	base = A*X + B*Y
	
	if X == Y:
		tmp == C * 2 * Y
		
		print(min(base, tmp))
		sys.exit()
	
	if X < Y:
		if A <= C:
			part1 = A*X
			part21 = C*2*Y
			part22 = B*Y
			tmp = min(part21,part22)
			tmp = part1 + tmp
			print(min(base, tmp))
			sys.exit()
				
		else:
			part1 = C*2*X
			Y -= X
			part21 = C*2*Y
			part22 = B*Y
			tmp = min(part21,part22)
			tmp = part1 + tmp
			print(min(base, tmp))
			sys.exit()
	else:
		if B <= C:
			part1 = B*Y
			part21 = C*2*X
			part22 = A*X
			tmp = min(part21,part22)
			tmp = part1 + tmp
			print(min(base, tmp))
			sys.exit()
				
		else:
			part1 = C*2*Y
			X -= Y
			part21 = C*2*X
			part22 = A*X
			tmp = min(part21,part22)
			tmp = part1 + tmp
			print(min(base, tmp))
			sys.exit()
			
	
if __name__ == "__main__":
	main()


### FIXED CODE ###

# -*- coding: utf-8 -*-
import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import numpy as np
import statistics
from statistics import mean, median,variance,stdev
import math

def main():
	A,B,C,X,Y = map(int, input().split(" "))
	
	if C >= A and C >= B:
		
		print(A*X + B*Y)
		sys.exit()
	
	base = A*X + B*Y
	
	if X == Y:
		tmp = C * 2 * Y
		
		print(min(base, tmp))
		sys.exit()
	

	part1 = A*X
	part21 = C*2*Y
	part22 = B*Y
	tmp = min(part21,part22)
	tmp = part1 + tmp
	ans = min(base, tmp)
	#print(ans)
			
	part1 = C*2*X
	Y_tmp = Y-X
	if Y_tmp > 0:	
		part21 = C*2*Y_tmp
		part22 = B*Y_tmp
		tmp = min(part21,part22)
		tmp = part1 + tmp
	else:
		tmp = part1
	ans = min(ans, tmp)
	#print(ans)
	
	part1 = B*Y
	part21 = C*2*X
	part22 = A*X
	tmp = min(part21,part22)
	tmp = part1 + tmp
	ans = min(ans, tmp)
	#print(ans)
		
	part1 = C*2*Y
	X -= Y
	if X > 0:
		part21 = C*2*X
		part22 = A*X
		tmp = min(part21,part22)
		tmp = part1 + tmp
	else:
		tmp = part1
	ans = min(ans, tmp)
			
	print(ans)
	
if __name__ == "__main__":
	main()
s = list(input())
mods = [0]*(len(s))
countRemainder = [0] * 2019
cnt = 0

for i in range(len(s)):
    if i == 0:
        mods[0] = int(s[-1])
    else:
        mods[i] = mods[i-1] + (10**i % 2019) * int(s[len(s) - i - 1])
    countRemainder[mods[i]] += 1

countRemainder[0] += 1

for i in range(2019):
    cnt += int(countRemainder[i] * (countRemainder[i] - 1) / 2)

print(cnt)



### FIXED CODE ###

s = list(input())
mods = [0]*(len(s))
countRemainder = [0] * 2019
cnt = 0


m = 1
mod = 0
for i in range(len(s)):
    mod += int(s[len(s) - i - 1]) * m

    mod %= 2019
    m *= 10
    m %= 2019

    countRemainder[mod] += 1

countRemainder[0] += 1

for i in range(2019):
    cnt += int(countRemainder[i] * (countRemainder[i] - 1) / 2)

print(cnt)
in = input().split()

a = int(in[0])
b = int(in[1])
c = int(in[2])

if b / a < c:
  print(b/ a)
else:
  print(c)


### FIXED CODE ###

in1 = input().split()

a = int(in1[0])
b = int(in1[1])
c = int(in1[2])

if b / a < c:
  print(int(b / a))
else:
  print(c)
#ITP1_4_C:   Simple Calculator
while True:
    a, op, b = input().split()
    a, b = int(a), int(b)
    if op == '?':
        break
    elif op =='+':
        print(a+b) +1
    elif op =='-':
        print(a-b)    
    elif op =='*':
        print(a*b)
    elif op =='/':
        print(a//b)

### FIXED CODE ###

#ITP1_4_C:   Simple Calculator
while True:
    a, op, b = input().split()
    a, b = int(a), int(b)
    if op == '?':
        break
    elif op =='+':
        print(a+b) 
    elif op =='-':
        print(a-b)    
    elif op =='*':
        print(a*b)
    elif op =='/':
        print(a//b)
n, m = map(int, input().split())
bad = []
for i in range(m):
    bad.append(int(input()))
dp = [0 for x in range(n+1)]
dp[0] = 1
idx = 0
if bad[0] == 1:
    dp[1] = 0
    idx = 1
else:
    dp[1] = 1

for i in range(2, n+1):
    if idx < m and i == bad[idx]:
        dp[i] = 0
        idx+=1
    else:
        dp[i] = (dp[i-1] + dp[i-2]) % 1000000007

print(dp[n])





### FIXED CODE ###

n, m = map(int, input().split())
bad = []
for i in range(m):
    bad.append(int(input()))
dp = [0 for x in range(n+1)]
dp[0] = 1
idx = 0
if m > 0 and bad[0] == 1:
    dp[1] = 0
    idx = 1
else:
    dp[1] = 1

for i in range(2, n+1):
    if idx < m and i == bad[idx]:
        dp[i] = 0
        idx+=1
    else:
        dp[i] = (dp[i-1] + dp[i-2]) % 1000000007

print(dp[n])
#query=10**4*2
#alph=26
#insert=500000
#O(|insert*query*alph|)?
def main():
	import bisect
	input=sys.stdin.readline
	n=int(input())
	s=list(input().rstrip())
	q=int(input())
	word=[[]for _ in range(26)]
	for i,j in enumerate(s):
		ch=ord(j)-ord("a")
		word[ch].append(i)
	for _ in range(q):
		query=input().split()
		if query[0]=="1":
			i,x=int(query[1])-1,ord(query[2])-ord("a")
			old=ord(s[i])-ord("a")
			word[old].remove(i)
			new=bisect.bisect_left(word[x],i)
			word[x].insert(new,i)
			s[i]=x
		else:
			l,r=int(query[1])-1,int(query[2])-1
			kind=0
			for i in range(26):
				l=bisect.bisect_left(word[i],l)
				if l==len(word[i]):
					continue
				if word[i][l]<=r:
					kind+=1
			print(kind)
if __name__ == '__main__':
	main()

### FIXED CODE ###

import sys
input=sys.stdin.readline
n=int(input())
BIT=[[0]*n for i in range(26)]
w=[ord(x)-ord("a") for x in input()]
for i in range(n):
	k=i+1
	while k<=n:
		BIT[w[i]][k-1]+=1
		k=k+(k&-k)
q=int(input())
for i in range(q):
	a,b,c=input().split()
	if a=="1":
		k=int(b)
		while k<=n:
			BIT[ord(c)-ord("a")][k-1]+=1
			k=k+(k&-k)
		k=int(b)
		while k<=n:
			BIT[w[int(b)-1]][k-1]-=1
			k=k+(k&-k)	
		w[int(b)-1]=ord(c)-ord("a")
	else:
		b=int(b);c=int(c)
		ans=0
		for i in range(26):
			cnt=0
			k=c
			while k!=0:
				cnt+=BIT[i][k-1]
				k=k-(k&-k)
			k=b-1
			while k!=0:
				cnt-=BIT[i][k-1]
				k=k-(k&-k)
			if cnt>0:
				ans+=1
		print(ans)
n,m = map(int,input().split())
li=[list(map(int,input().split())) for i in range(m)]
max_l,min_r=0,10**9

for i in li:
    max_l = max(max_l,li[0])
    min_r = min(min_r,li[1])
print(min_r-max_l+1)

### FIXED CODE ###

n,m = map(int,input().split())
li=[list(map(int,input().split())) for i in range(m)]
max_l,min_r=0,10**9

for i in li:
    max_l = max(max_l,i[0])
    min_r = min(min_r,i[1])
if min_r >= max_l:
    print(min_r-max_l+1)
else:
  print(0)
import math
a, b = map(int, input(), split(　))
print(math.ceil((a + b) / 2))

### FIXED CODE ###

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

print(math.ceil((a + b) / 2))
def shortest_path(s,n,w,es):
#s→iの最短距離
# s:始点, n:頂点数, w:辺の数, es[i]: [辺の始点,辺の終点,辺のコスト]
    d = [float('inf')] * n
    #d[i] : s→iの最短距離
    d[s] = 0
    while True:
        update = False
        for p,q,r in es:
        # e: 辺iについて [from,to,cost]
            #print(d,p,q,r)
            if d[p] != float('inf') and d[q] > d[p] + r:
                d[q] = d[p] + r
                update = True
            if not update:
                print(1)
                break
            ans1=d[-1]
        update = False
        for p,q,r in es:
        # e: 辺iについて [from,to,cost]
            #print(d,p,q,r)
            if d[p] != float('inf') and d[q] > d[p] + r:
                d[q] = d[p] + r
                update = True

            ans2=d[-1]
        return -ans1 if ans1==ans2 else 'inf' 
################
n,w = map(int,input().split()) #n:頂点数　w:辺の数
es = [] #es[i]: [辺の始点,辺の終点,辺のコスト]
for _ in range(w):
 x,y,z = map(int,input().split())
 es.append([x-1,y-1,-z])
print(shortest_path(0,n,w,es))

### FIXED CODE ###

def shortest_path(s,n,w,es):
#s→iの最短距離
# s:始点, n:頂点数, w:辺の数, es[i]: [辺の始点,辺の終点,辺のコスト]
    d = [float('inf')] * n
    #d[i] : s→iの最短距離
    d[s] = 0
    while True:
        for p,q,r in es:
        # e: 辺iについて [from,to,cost]
            #print(d,p,q,r)
            if d[p] != float('inf') and d[q] > d[p] + r:
                d[q] = d[p] + r
                update = True
            ans1=d[-1]
        update = False
        for p,q,r in es:
        # e: 辺iについて [from,to,cost]
            #print(d,p,q,r)
            if d[p] != float('inf') and d[q] > d[p] + r:
                d[q] = d[p] + r
            ans2=d[-1]
        return -ans1 if ans1==ans2 else 'inf' 
################
n,w = map(int,input().split()) #n:頂点数　w:辺の数
es = [] #es[i]: [辺の始点,辺の終点,辺のコスト]
for _ in range(w):
 x,y,z = map(int,input().split())
 es.append([x-1,y-1,-z])
print(shortest_path(0,n,w,es))
N=int(input())
K=int(input())
if N<=10**6:
  ans=0
  for i in range(1,N+1):
    a=str(i)
    if len(a)-list(a).count("0")==K:
      ans+=1
  print(ans)
  exit()
L=list(map(int,list(str(N))))
ans=0
L=list(map(int,list(str(N))))
for i in range(N,N+1001):
  L=list(map(int,list(str(i))))
  s=L[:3]
  if s[0]!=0 and s[1]!=0 and s[2]!=0:
    go=i
    break
for i in range(N+1,go+1):
  a=str(i)
  if len(a)-list(a).count("0")==K:
    ans-=1
if K==1:#おけ
  print((len(str(N))-1)*9+int(str(N)[0]))
elif K==2:#おけ
  N=go
  for i in range(len(L)-1):
    ans+=(9*(int(str(N)[0])-1))
    for j in range(i+1,len(L)):
      if i==0:
        if j==1:
          ans+=int(str(N)[1])
        else:
          ans+=9
      else:
        ans+=81
  print(ans)
else:
  N=go
  le=len(L)
  for i in range(le-2):
    for j in range(i+1,le-1):
      for k in range(j+1,le):
        if i==0:
          ans+=81*(int(str(N)[0])-1)
          if j==1:
            ans+=9*(int(str(N)[1])-1)
            if k==2:
              ans+=int(str(N)[2])
            else:
              ans+=9
          else:
            ans+=81
        else:
          ans+=729
  print(ans)

### FIXED CODE ###

n=int(input())
k=int(input())
def main(N,K):
  ans=0
  if N<=100+10**6:
    for i in range(1,N+1):
      a=str(i)
      if len(a)-list(a).count("0")==K:
        ans+=1
    return ans
  L=list(map(int,list(str(N))))
  ans=0
  L=list(map(int,list(str(N))))
  if K==1:#おけ
    return (len(str(N))-1)*9+int(str(N)[0])
  elif K==2:#おけ
    for i in range(len(L)-1):
      ans+=(9*(int(str(N)[0])-1))
      for j in range(i+1,len(L)):
        if i==0:
          if j==1:
            ans+=int(str(N)[1])
          else:
            ans+=9
        else:
          ans+=81
    return ans
  else:
    le=len(L)
    for i in range(le-2):
      for j in range(i+1,le-1):
        for k in range(j+1,le):
          if i==0:
            ans+=81*(int(str(N)[0])-1)
            if j==1:
              ans+=9*(int(str(N)[1])-1)
              if k==2:
                ans+=int(str(N)[2])
              else:
                ans+=9
            else:
              ans+=81
          else:
            ans+=729
    return ans
ans2=0
L=list(str(n))
a=len(L)
for i in range(a):
  L=list(str(n))
  s=L[:a-i-1]
  t=L[a-i-1:]
  t=int("".join(t))
  p=s.count("0")
  p=len(s)-p
  if p>k:
    n-=t+1
  elif p==k:
    n-=t+1
    ans2+=1
  else:
    ans2+=main(t,k-p)
    n-=t+1
print(ans2)
a,b = map(int,input().split())

if a =< b:
  print(a)
else:
  print(a-1)

### FIXED CODE ###

a,b = map(int,input().split())
 
if a <= b:
  print(a)
else:
  print(a-1)
n = int(input())

if n == 1:
    print(1/a)
elif n % 2 == 0:
    print(1/2)
else:
    print(((a+1)/2)/a)

### FIXED CODE ###

a = int(input())

if a == 1:
    print(1/a)
elif a % 2 == 0:
    print(1/2)
else:
    print(((a+1)/2)/a)
def next_pos(D,L):
    return D+L
    
N, X = map(int,input().split(" "))
L = [int(i) for i in input().split(" ")]
D = 0
count = 0
i = 0

while(D<=X):
    D = next_pos(D,L[i])
    count+=1
    i+=1
    
print(count)

### FIXED CODE ###

N, X = map(int,input().split(" "))
L = [int(i) for i in input().split(" ")]
D = 0
count = 1
for i in range(N):
    D+=L[i]
    if D<=X:
        count+=1
    
print(count)
N = int(input())
if int(N)%10 = 3:
 print('bon')
elif int(N)%10 = 0 or 1 or 6 or 8:
 print('pon')
else:
 print('hon')

### FIXED CODE ###

N = int(input())

if N % 10 == 3:
 print('bon')
elif N % 10 == 0:
 print('pon')
elif N % 10 == 1:
 print('pon')
elif N % 10 == 6:
 print('pon')
elif N % 10 == 8:
 print('pon')
else:
 print('hon')
def main():
    from collections import deque
    from functools import reduce
    from math import gcd

    n, *a = map(int, open(0).read().split())
    q = deque(a)
    ans = 0
    for i in range(n):
        t = q.popleft()
        g = reduce(gcd, q)
        ans = max(ans, g)
        q.append(t)
        q.rotate(-1)
    print(ans)

if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    from fractions import gcd

    n, *a = map(int, open(0).read().split())
    a = [0] + a + [0]
    l = [0 for _ in range(n + 1)]
    r = [0 for _ in range(n + 1)]
    tmpl = 0
    tmpr = 0
    for i in range(1,n+1):
        tmpl = gcd(tmpl, a[i-1])
        tmpr = gcd(tmpr, a[-i])
        l[i] = tmpl
        r[-i] = tmpr

    ans = 0
    for i, j in zip(l, r):
        g = gcd(i, j)
        ans = max(ans, g)

    print(ans)


if __name__ == '__main__':
    main()
N, M = map(int, input().split())
n_switch = []
switch = []
for i in range(M):
	s = list(map(int, input().split()))
	n_switch.append(s[0])
	switch.append(s[1:])
p = list(map(int, input().split()))
ans = 0
for i in range(2 ** N):
	x = 1
	b = bin(i)[2:].rjust(N, '0')
	for j in range(M):
		n_light = 0
		for k in range(n_switch[j]):
			if b[switch[j][k] - 1] == '1':
				n_light += 1
		if n_light % 2 != p[j]:
			x *= 0
			break
	if x == 1:
		ans += 1
print(ans)

### FIXED CODE ###

A, P = map(int, input().split())
print((3 * A + P) // 2)
h=int(input())
count=0
while  h>1:
	h = h // 2
	conut += 1
print(2 ** (count+1) - 1)

### FIXED CODE ###

h=int(input())
count=0
while  h>1:
	h = h // 2
	count += 1
print(2 ** (count+1) - 1)
n,m = map(int, input().split())
h_list = list(map(int, input().split())) #元リスト（変えない）
newlist = list(h_list) #変換用リスト
for i in range(m):
    a, b = map(int, input().split())
    if h_list[a-1] < h_list[b-1]:
        newlist[a-1] = 0
    elif h_list[a-1] > h_list[b-1]:
        newlistlist[b-1] = 0
    else:
        newlist[a-1] = 0
        newlist[b-1] = 0
print(n - newlist.count(0))

### FIXED CODE ###

n,m = map(int, input().split())
h_list = list(map(int, input().split()))
newlist = list(h_list)
for i in range(m):
    a, b = map(int, input().split())
    if h_list[a-1] < h_list[b-1]:
        newlist[a-1] = 0
    elif h_list[a-1] > h_list[b-1]:
        newlist[b-1] = 0
    else:
        newlist[a-1] = 0
        newlist[b-1] = 0
print(len(h_list) - newlist.count(0))
S, W = map(int, input().split())

if W >= S:
    print(unsafe)
else:
    print(safe)


### FIXED CODE ###

S, W = map(int, input().split())

if W>=S:
    print("unsafe")
else:
    print("safe")
from string import ascii_lowercase

s = input()
d = dict(zip(ascii_lowercase, [0 for _ in range(len(ascii_lowercase))]))
nex = ""
for c in s:
    d[c] += 1

if len(s) < 26:
    for k, v in d.items():
        if v == 0:
            print(s + k)
            exit()
elif s == "zyxwvutsrqponmlkjihgfedcba":
    print(-1)
    exit()

idx = -1
for i in range(1, len(s)):
    if s[i] > s[i + 1]:
        idx = i
        break
check = dict(zip(ascii_lowercase, [False for _ in range(len(ascii_lowercase))]))
for i in range(idx):
    check[s[i]] = True
i = 0
for c, v in check.items():
    if v == False:
        print(s[: i - 1] + c)
        exit()
    i += 1


### FIXED CODE ###

from string import ascii_lowercase
alphabets = ascii_lowercase
s = input()
if len(s) < len(alphabets):
    for c in alphabets:
        if c not in s:
            print(s + c)
            exit()
if s == "zyxwvutsrqponmlkjihgfedcba":
    print(-1)
    exit()

# 14253 next 143,  54213 next 5423, 35421 next 4, 43521 next 45
# 右端からみてi-1, iを比較して減少(S[i]>S[i-1])してたらi-1を基準に切り替える
# 切り替えるのは勘だけどi-1より右側でi-1より大きい最小のやつ？
for i in range(len(s) - 1, 0, -1):
    if s[i] > s[i - 1]:
        t = []
        for j in range(i, len(s)):
            if s[i - 1] < s[j]:
                t.append(s[j])
        x = min(t)
        print(s[:i - 1] + x)
        exit()
A = int(input())
B = int(input())

if A > B:
  max = A + A
  print(max)
elif B > A:
  max = B + B
  print(max)
elif A = B:
  max = A + B
  print(max)

### FIXED CODE ###

A,B = map(int,input().split())
 
if A > B:
  max = A + A - 1
  print(max)
elif B > A:
  max = B + B - 1
  print(max)
elif A == B:
  max = A + B
  print(max)
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

H, W = MAP()
a = [LIST() for _ in range(H)]

op = []
for i in range(H):
	for j in range(W-1):
		if a[i][j]%2:
			a[i][j] -= 1
			a[i][j+1] += 1
			op.append((i+1, j+1, i+1, j+2))

for i in range(H):
	if a[i][-1]%2:
		a[i][-1] -= 1
		a[i+1][-1] += 1
		op.append((i+1, W, i+2, W))

print(len(op))
print(*[" ".join(map(str, x)) for x in op], sep = "\n")

### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

H, W = MAP()

a = [LIST() for _ in range(H)]
cnt = 0

ans = []
for y in range(H):
	x = 0
	while x < W:
		if x < W-1 and a[y][x]%2:
			ans.append((y+1, x+1, y+1, x+2))
			cnt += 1
			a[y][x] -= 1
			a[y][x+1] += 1
		x += 1

y = 0
while y < H-1 :
	if a[y][-1]%2:
		ans.append((y+1, W, y+2, W))
		cnt += 1
		a[y][-1] -= 1
		a[y+1][-1] += 1
	y += 1

print(cnt)
for x in ans:
	print(*x)
S  = input()
S[3] = '8'
print(S)

### FIXED CODE ###

S  = list(input())
S[3] = '8'
s = "".join(S)
print(s)
def f():
 n,c=map(int,input().split())
 for h in'9731':
  if n>1:
   for m in range(int(10**(n-1)),0,-1):
    if((int(h)+m-1)*2+(c>=0)*c)%3:
     t=h+str(m-1).zfill(n-1)
     a=int(t+str(c)*(c>=0)+t[::-1])
     if 2 in[a,pow(2,a,a)]:
      for i in range(3,int(a**.5+1),2):
       if a%i==0:break
      else:return a
  else:
   a=int(h+str(c)*(c>=0)+h)
   if 2 in[a,pow(2,a,a)]:
    for i in range(3,int(a**.5+1),2):
     if a%i==0:break
    else:return a
 return'9'*n+str(c)*(c>=0)+'9'*n
print(f())


### FIXED CODE ###

def p(x):
 for i in range(3,int(x**.5+1),2):
  if x%i==0:return 0
 return 1
def f():
 n,c=map(int,input().split())
 s='9'*n
 if c<0:return(11,s+s)[n>1]
 for h in'9731':
  if n-1:
   for m in range(int(10**~-n),0,-1):
    t=h+str(m-1).zfill(n-1)
    a=int(t+str(c)+t[::-1])
    if p(a):return a
  else:
   a=int(h+str(c)+h)
   if p(a):return a
 return s+str(c)+s
print(f())
n=int(input())
lists=[]
lists1=[]
for i in range(n):
    a,b=map(int,input().split())
    lists.append((a+b,a,b))
listed=sorted(lists,key=lambda x:x[0],reverse=True)

ans=0
for n in range(n):
if n%2==0:
    ans+=listed[n][1]
    
elif n%2!=0:
    ans-=listed[n][2]
print(ans)
    

### FIXED CODE ###

n=int(input())
lists=[]
lists1=[]
for i in range(n):
    a,b=map(int,input().split())
    lists.append((a+b,a,b))
listed=sorted(lists,key=lambda x:x[0],reverse=True)

ans=0
for n in range(n):
    if n%2==0:
        ans+=listed[n][1]
    
    elif n%2!=0:
        ans-=listed[n][2]
print(ans)
import math
from collections import Counter as ct
from functools import reduce

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

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

def yakusulist(n):
    ans=[]
    for i in range(1,int(math.sqrt(n+1))+1):
        if n%i==0:
            ans.append(i)
            ans.append(n//i)
    return(set(ans))
    
def warennnokaomaera(n):
    if n==1:return(True)
    for k,i in enumerate(A):
        if k<3:continue
        if i%n:return(False)
    return(True)

N=int(input())
data=[int(i) for i in input().split()]
datagcd=gcd_list(data)
A=[i//datagcd for i in data]
if N>2:
    alpha=sorted(ct(A).keys())
    min3=[alpha[0],alpha[1],alpha[2]]
    p,q,r=[yakusulist(n) for n in min3]
    pq=p&q
    qr=q&r
    rp=r&p
    overtwo=pq|qr|rp
    overtwo=sorted(list(overtwo),reverse=True)
    for i in overtwo:
        if warennnokaomaera(i):
            print(datagcd*i)
            break
else:print(max(data))

### FIXED CODE ###

import math
import fractions
from collections import Counter as ct

def gcd_list(l):
    for n,i in enumerate(l):
        if n==0:cur=i
        cur=fractions.gcd(cur,i)
    return cur

def yakusulist(n):
    ans=[]
    for i in range(1,int(math.sqrt(n+1))+1):
        if n%i==0:
            ans.append(i)
            ans.append(n//i)
    return(set(ans))
    
def warennnokaomaera(n):
    warenai=0
    for k,i in enumerate(A):
        if i%n and warenai==0:
            warenai+=1
            continue
        if i%n and warenai:return(False)
    return(True)

N=int(input())
data=[int(i) for i in input().split()]
datagcd=gcd_list(data)
A=[i//datagcd for i in data]
if N>2:
    co=ct(A)
    alpha=sorted(co.keys())
    if len(alpha)>=3:
        min3=[alpha[0],alpha[1],alpha[2]]
        p,q,r=[yakusulist(n) for n in min3]
        pq=p&q
        qr=q&r
        rp=r&p
        overtwo=pq|qr|rp
        overtwo=sorted(list(overtwo),reverse=True)
        for i in overtwo:
            if warennnokaomaera(i):
                print(datagcd*i)
                break
    elif len(alpha)==2:#Aの数の種類が2種類以下->1個書き換えで違う数ってどっちかが一個じゃないと無理、それ以外はそのまま
        if co[alpha[0]]==1:
            print(datagcd*alpha[1])
        elif co[alpha[1]]==1:
            print(datagcd*alpha[0])
        else:print(datagcd)
    else:print(datagcd)
else:print(max(data))
lst = list(map(int, input().split(' ')))
for i in sorted(lst):
  print('{} '.format(i), end='')

### FIXED CODE ###

lst = list(map(int, input().split()))
for i, data in enumerate(sorted(lst)):
    if not i == len(lst)-1:
        print('{} '.format(data), end='')
    else:
        print('{}'.format(data))
a, b = map(int, input().split())
s = input()
try:
    first, second = s.split("-")
    if len(first) == a and len(second) == b:
        print("Yes")
    else:  
        print("No")
except:
    print("No")

### FIXED CODE ###

a = int(input())
print(48-a)