Harryxun/stf_run huggingface dataset:
import numpy as np

area = [[0 for i in range(10)] for j in range(10)]
area = np.array(area)

while True:
    try:
        y, x, s = map(int, input().split(','))
    except:
        break

    if s == 3:
        if (0 <= x+2 <= 9) and (0 <= y <= 9):
            area[x+2][y] += 1
        if (0 <= x <= 9) and (0 <= y+2 <= 9):
            area[x][y+2] += 1
        if (0 <= x-2 <= 9) and (0 <= y <= 9):
            area[x-2][y] += 1
        if (0 <= x <= 9) and (0 <= y-2 <= 9):
            area[x][y-2] += 1
    if s >= 2:
        if (0 <= x+1 <= 9) and (0 <= y+1 <= 9):
            area[x+1][y+1] += 1
        if (0 <= x+1 <= 9) and (0 <= y-1 <= 9):
            area[x+1][y-1] += 1
        if (0 <= x-1 <= 9) and (0 <= y+1 <= 9):
            area[x-1][y+1] += 1
        if (0 <= x-1 <= 9) and (0 <= y-1 <= 9):
            area[x-1][y-1] += 1
    if s >= 1:
        if (0 <= x+1 <= 9) and (0 <= y <= 9):
            area[x+1][y] += 1
        if (0 <= x <= 9) and (0 <= y+1 <= 9):
            area[x][y+1] += 1
        if (0 <= x-1 <= 9) and (0 <= y <= 9):
            area[x-1][y] += 1
        if (0 <= x <= 9) and (0 <= y-1 <= 9):
            area[x][y-1] += 1
        area[x][y] += 1
        print(area)

print(len(np.where(area == 0)[0]))
print(area.max())

### FIXED CODE ###

def check(x, y):
    return 0 <= x <= 9 and 0 <= y <= 9


def small(x, y, area):
    if check(x+1, y):
        area[x+1][y] += 1
    if check(x, y+1):
        area[x][y+1] += 1
    if check(x-1, y):
        area[x-1][y] += 1
    if check(x, y-1):
        area[x][y-1] += 1
    area[x][y] += 1
    return area


def mediam(x, y, area):
    area = small(x, y, area)
    if check(x+1, y+1):
        area[x+1][y+1] += 1
    if check(x+1, y-1):
        area[x+1][y-1] += 1
    if check(x-1, y+1):
        area[x-1][y+1] += 1
    if check(x-1, y-1):
        area[x-1][y-1] += 1
    return area


def large(x, y, area):
    area = mediam(x, y, area)
    if check(x+2, y):
        area[x+2][y] += 1
    if check(x, y+2):
        area[x][y+2] += 1
    if check(x-2, y):
        area[x-2][y] += 1
    if check(x, y-2):
        area[x][y-2] += 1
    return area

area = [[0 for i in range(10)] for j in range(10)]

while True:
    try:
        x, y, s = map(int, input().split(','))
    except:
        break

    if s == 1:
        area = small(x, y, area)
    if s == 2:
        area = mediam(x, y, area)
    if s == 3:
        area = large(x, y, area)

max = 0
cnt = 0

for i in range(10):
    for j in range(10):
        if area[i][j] == 0:
            cnt += 1
        if area[i][j] > max:
            max = area[i][j]
print(cnt)
print(max)
n=input().split(" ")
a=int(n[0])
b=int(n[1])
c=int(n[2])
count=0
for i in range(n+1):
    count=i+1
print(count)


### FIXED CODE ###

x=input().split(" ")
a=int(x[0])
b=int(x[1])
c=int(x[2])
count=0
for i in range(a,b+1):
  if c%i==0:
   count+=1
print(count)
A,B,N=map(int,iput(),split())
if A*N<B :
  print("A*N")
else:
  print("B")

### FIXED CODE ###

N,A,B=map(int,input().split())
if A*N<B :
  print(A*N)
else:
  print(B)
n = int(input())
U = list(input())
input()

mod = 1000000007

idx = 0
li = []
while idx < len(U) - 1:
  if U[idx] == U[idx + 1]:
    li.append(2)
    idx += 1
  else:
    li.append(1)
  idx += 1
if U[-1] != U[-2]:
  li.append(1)

ans = 1
pre = li[0]

if pre == 1:
  ans = ans * 3 % mod
else:
  ans = ans * 6 % mod
  
for i in li[1:]:
  if pre == 1:
    ans = ans * 2 % mod
  else:
    if i == 2:
      ans = ans * 3 % mod
  pre = i

print(ans)

### FIXED CODE ###

n = int(input())
U = list(input())
input()

mod = 1000000007

if n == 1:
  print(3)
  exit()

idx = 0
li = []
while idx < len(U) - 1:
  if U[idx] == U[idx + 1]:
    li.append(2)
    idx += 1
  else:
    li.append(1)
  idx += 1
if U[-1] != U[-2]:
  li.append(1)

ans = 1
pre = li[0]

if pre == 1:
  ans = ans * 3 % mod
else:
  ans = ans * 6 % mod
  
for i in li[1:]:
  if pre == 1:
    ans = ans * 2 % mod
  else:
    if i == 2:
      ans = ans * 3 % mod
  pre = i

print(ans)
a,b = [int(i) for in input().split()]

res = int(str(a)+str(b))**0.5
if int(res)==res:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

a,b = [int(i) for i in input().split()]

res = int(str(a)+str(b))**0.5
if int(res)==res:
  print("Yes")
else:
  print("No")
n, m = map(int, input().split())
a = map(int, input().split())
a = array.array("L", sorted(list(a)))
for _ in range(m):  # O(m*n)
  max_num = a.pop()  # O(1)
  index = bisect.bisect(a, max_num // 2)  # O(log n)
  a.insert(index, max_num // 2)  # O(n)
  print(sum(a))

### FIXED CODE ###

class heap():
    def __init__(self, maxcom=True):
        if maxcom:
            self.compare = lambda x, y: x > y
        else:
            self.compare = lambda x, y: x < y

    def heappush(self, x, heap):
        heap.append(x)
        length = len(heap)
        pointer = length
        while True:
            if pointer == 1:
                break
            if self.compare(heap[pointer - 1], heap[(pointer >> 1) - 1]):
                heap[pointer - 1], heap[(pointer >> 1) - 1] = heap[(pointer >> 1) - 1], heap[pointer - 1]
                pointer = pointer >> 1
            else:
                break

    def heapreplace(self, function, heap):
        heap[0] = function(heap[0])
        pointer = 1
        length = len(heap)
        while True:
            if (pointer << 1) > length:
                break
            elif (pointer << 1) + 1 > length :
                if self.compare(heap[(pointer << 1) - 1], heap[pointer - 1]):
                    heap[(pointer << 1) - 1], heap[pointer - 1] = heap[pointer - 1], heap[(pointer << 1) - 1]
                else:
                    break
            else:
                if self.compare(heap[(pointer << 1) - 1], heap[pointer << 1]):
                    next_pointer = pointer << 1
                else:
                    next_pointer = (pointer << 1) + 1
                if self.compare(heap[next_pointer - 1], heap[pointer - 1]):
                    heap[next_pointer - 1], heap[pointer - 1] = heap[pointer - 1], heap[next_pointer - 1]
                    pointer=next_pointer
                else:
                    break


n, m = map(int, input().split())
a = map(int, input().split())
heapq = []
heapc=heap(True)
for i in a:
    heapc.heappush(i,heapq)
for _ in range(m):
    heapc.heapreplace(lambda x:x>>1,heapq)
print(sum(heapq))
n = int(input())
a_list = list(map(int, input().split()))
import math
def dfs(lis, i):
    if i == 0:
        return lis[0]
    if i >0:
        ans = math.gcd(dfs(lis,i-1),lis[i])
        return ans
print(dfs(a_list,n-1))

### FIXED CODE ###

import math
n= int(input())
a_list = list(map(int, input().split()))
gcd = a_list[0]
for i in range(1,n):
    gcd = math.gcd(gcd,a_list[i])
    
    
print(gcd)
N, K = map(int, input().split())
V = [int(i) for i in input().split()]

ans = -1
for i in range(K + 1): #i個ゲット
    for l in range(i + 1): #左からいくつのindexまでとるか
        a = V[0:l] + V[N - (i - l):N]
        a.sort()

        # K- i 個負のvalueを捨てれる
        t = 0
        s = sum(a)
        while i > t and K - i > t:
            if a[t] >= 0:
                break
            s -= a[t] #負の減算なので加算
            t += 1
        ans = max(ans, s)

print(ans)


### FIXED CODE ###

N, K = map(int, input().split())
V = [int(i) for i in input().split()]

ans = -1
for i in range(min(N + 1, K + 1)): #i個ゲット
    for l in range(i + 1): #左からいくつのindexまでとるか
        a = V[0:l] + V[N - (i - l):N]
        a.sort()

        # K- i 個負のvalueを捨てれる
        t = 0
        s = sum(a)
        while i > t and K - i > t:
            if a[t] >= 0:
                break
            s -= a[t] #負の減算なので加算
            t += 1
        ans = max(ans, s)

print(ans)
import itertools

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

mod=10**9+7

#x以下の素数の列挙
    
import math

x=math.floor(math.sqrt(10**9))

L=math.floor(math.sqrt(x))#平方根を求める

Primelist=[i for i in range(x+1)]
Primelist[1]=0#素数でないものは0にする.
 
for i in Primelist:
    if i>L:
        break
    if i==0:
        continue
    for j in range(2*i,x+1,i):
        Primelist[j]=0

Primes=[Primelist[j] for j in range(x+1) if Primelist[j]!=0]

def fact(M):
    LIST=[]
    i=0
    while M!=1:
        if M%Primes[i]==0:
            LIST.append(Primes[i])
            M=M//Primes[i]
        else:
            i+=1

    PE=list(itertools.product(range(0,2),repeat=len(LIST)))

    SET={1}

    for pe in PE:
        ANS=1

        for j in range(len(LIST)):
            if pe[j]==1:
                ANS=ANS*LIST[j]

  

        SET=SET|{ANS}

    return SET

SET=fact(M)
factor=dict()

for j in SET:
    factor[j]=fact(j)

    
DP=dict()
def dp(n,m):
    if n==1 or m==1:
        return 1
    
    ANS=0
    for j in factor[m]:
        if DP.get((n-1,m//j),-1)!=-1:
            ANS=(ANS+DP[n-1,m//j])%mod
        else:
            ANS=(ANS+dp(n-1,m//j))%mod

    DP[n,m]=ANS%mod
    return ANS
    
for i in range(1,N,10):
    dp(i,M)

print(dp(N,M))
    
    


### FIXED CODE ###

N,M=map(int,input().split())
mod=10**9+7

#x以下の素数の列挙   
import math
x=math.floor(math.sqrt(10**9))
L=math.floor(math.sqrt(x))#平方根を求める
Primelist=[i for i in range(x+1)]
Primelist[1]=0#素数でないものは0にする.
for i in Primelist:
    if i>L:
        break
    if i==0:
        continue
    for j in range(2*i,x+1,i):
        Primelist[j]=0
Primes=[Primelist[j] for j in range(x+1) if Primelist[j]!=0]

#素因数分解
DICT=dict()
i=0
while M!=1:
    if M%Primes[i]==0:
        DICT[i]=DICT.get(i,0)+1
        M=M//Primes[i]
    elif i<len(Primes)-1:
        i+=1
    else:
        DICT[M]=1
        M=1

def Combi2(a,b):#aは大きいが、bは小さいとき
    ANS=1
    for i in range(min(b,a-b)):
        ANS=ANS*(a-i)%mod*pow(b-i,mod-2,mod)%mod

    return ANS%mod


ANS=1
for i in DICT.values():
    ANS=ANS*Combi2(N-1+i,i)%mod

print(ANS)
abc=  imput()
 
a, b, c = abc.split(' ')
if a[-1] == b[0] and b[-1] == c[0]:
    print('YES')
else:
    print('NO')


### FIXED CODE ###

abc=  input()
 
a, b, c = abc.split(' ')
if a[-1] == b[0] and b[-1] == c[0]:
    print('YES')
else:
    print('NO')
import sys


if __name__ == '__main__':
    print(f"{sys.argv[-1]} {sys.argv[1]} {sys.argv[2]}")


### FIXED CODE ###

import sys


if __name__ == '__main__':
    a, b, c = map(int, input().split())
    print(c, a, b)
N, M = [int(i) for i in input().split()]

if N >= 700:
      print(aaa)
    
else:
  print("a")


### FIXED CODE ###

from collections import defaultdict
from heapq import heappop, heappush


class Graph(object):
    """
    隣接リストによる有向グラフ
    """

    def __init__(self):
        self.graph = defaultdict(list)

    def __len__(self):
        return len(self.graph)

    def add_edge(self, src, dst, weight=1):
        self.graph[src].append((dst, weight))

    def get_nodes(self):
        return self.graph.keys()


class Dijkstra(object):
    """
    ダイクストラ法（二分ヒープ）による最短経路探索
    計算量: O((E+V)logV)
    """

    def __init__(self, graph, start):
        self.g = graph.graph

        # startノードからの最短距離
        # startノードは0, それ以外は無限大で初期化
        self.dist = defaultdict(lambda: float('inf'))
        self.dist[start] = 0

        # 最短経路での1つ前のノード
        self.prev = defaultdict(lambda: None)

        # startノードをキューに入れる
        self.Q = []
        heappush(self.Q, (self.dist[start], start))

        while self.Q:
            # 優先度（距離）が最小であるキューを取り出す
            dist_u, u = heappop(self.Q)
            if self.dist[u] < dist_u:
                continue
            for v, weight in self.g[u]:
                alt = dist_u + weight
                if self.dist[v] > alt:
                    self.dist[v] = alt
                    self.prev[v] = u
                    heappush(self.Q, (alt, v))

    def shortest_distance(self, goal):
        """
        startノードからgoalノードまでの最短距離
        """
        return self.dist[goal]

    def shortest_path(self, goal):
        """
        startノードからgoalノードまでの最短経路
        """
        path = []
        node = goal
        while node is not None:
            path.append(node)
            node = self.prev[node]
        return path[::-1]


g = Graph()
N, M = [int(i) for i in input().split()]


for i in range(M):
    u, v = [int(i) for i in input().split()]
    g.add_edge(u-1, v-1, 1)
    g.add_edge(u-1+N, v-1, 1)
    g.add_edge(u-1, v-1+N, 1)

d = Dijkstra(g, 0)

ans_n = 10 ** 6
ans_index = -1
for i in range(N):
    d = Dijkstra(g, i)
    ans_n_ = d.dist[i+N]

    if ans_n_ < ans_n:
        ans_index = i
        ans_n = ans_n_

if ans_n == 10 ** 6:
    print(-1)
else:
    d = Dijkstra(g, ans_index)
    ans = d.shortest_path(ans_index + N)
    ans.sort()
    print(ans_n)
    for j in range(ans_n):
        print(ans[j]+1)
def password(n):

    return n**3
def main():
    n = list(str(input()))
    print(password(n))

if __name__ == '__main__':
    main()

### FIXED CODE ###

def password(n):

    return n**3
def main():
    n = int(input())
    print(password(n))

if __name__ == '__main__':
    main()
a,b,c,k=map(int,input().split())
if a > k:
    vis = [1]*a
elif a+b > k:
    vis=[1]*a+[0]*b
else:
    vis=[1]*a+[0]*b+[-1]*c
    
s = 0

sum(vis[0:k])
    
print(s)

### FIXED CODE ###

a,b,c,k=map(int,input().split())
if a >= k:
    vis = k
elif a + b >= k:
    vis = a
else:
    vis= a + (-1*(k-a-b))
    
print(vis)
N = int(input())

p = []

for _ in raneg(N):
    p.append(int(input()))


new_p = sorted(p, reverse=True)

new_p[0] = new_p[0]//2

print(sum(new_p))


### FIXED CODE ###

N = int(input())
p = []
for _ in range(N):
    p.append(int(input()))
p = sorted(p)
p[-1] = p[-1]//2
print(sum(p))
n,l = map(int, input().split())
a = []
ans = 0
for i in range(1, n+1):
  a.append([l + i - 1, abs(l + i - 1)])
a = sorted(a, key = lambda x:x[1], reverse = True)
a.pop()
for _ in range(n-1):
  ans += a[0]
print(ans)



### FIXED CODE ###

n,l = map(int, input().split())
a = []
ans = 0
for i in range(1, n+1):
  a.append([l + i - 1, abs(l + i - 1)])
a = sorted(a, key = lambda x:x[1], reverse = True)
a.pop()
for i in range(n-1):
  ans += a[i][0]
print(ans)
for _ in range(int(input())):
    a,b,c,d,e,f,g,h=map(float, input().split())
    if ((b-d)/(a-c)) == ((f-h)/(e-g)):
        print("Yes")
    else:
        print("No")

### FIXED CODE ###

for _ in range(int(input())):
    a,b,c,d,e,f,g,h=map(float, input().split())
    
    if abs((c-a)*(h-f) - (g-e)*(d-b)) < 1e-10:
        print("YES")
    else:
        print("NO")
# スペース区切りの整数の入力
n, y = map(int, input().split())

i = 0
j = 0
k = 0

l = [-1,-1,-1]
#print(l)

for i in reversed(range(0,n+1)):
    #print('i= %d' % i)
    if  y >= i*10000:
        for j in reversed(range(0,n-i+1)):
            #print('j= %d' % j)
            k = n - i - j
            #print('k= %d' % k)
            if  y == i*10000 + j*5000 + k*1000:
                l = [i, j, k]

#----ここは一つ見つかったら抜けるための命令
#                break
#        else:
#            continue
#        break
#------------------------------------

                #print(l)

print(l[0], l[1], l[2])


### FIXED CODE ###


s = input()

#print(s)

#文字を置き換える
print(s.replace('2017', '2018'))
A=list(map(int,input89.split()))
A.sort()
print(A[2]-A[0])


### FIXED CODE ###

A=list(map(int,input().split()))
A.sort()
print(A[2]-A[0])
n,m=map(int,input().split())

ab=[]
for _ in range(m):
    a,b=map(int,input().split())
    ab.append([a,b])

ab.sort((key=lambda x: x[1]))

cnt=0
border=0

for item in ab:
    if item[0]>=border:
        border=item[1]
        cnt+=1

print(cnt)



### FIXED CODE ###

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

ab=[]
for _ in range(m):
    a,b=map(int,input().split())
    ab.append([a,b])

ab.sort()

ll=ab[0][0]
rr=ab[0][1]

cnt=1
#print(ab[0],ll,rr,cnt)
for item in ab[1:]:
    l=item[0]
    r=item[1]
    if l>=rr:
        cnt+=1
        ll=l
        rr=r
    else:
        if r<rr:
            rr=r
        if ll<l:
            ll=l
    #print(item,ll,rr,cnt)

print(cnt)
#%%

#%%
n = int(input())

def factorize(n):
    b = 2
    fct = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            fct.append(b)
        b = b + 1
    if n > 1:
        fct.append(n)
    return fct

l = factorize(n)


import itertools
c = list(itertools.product(range(2), repeat=len(l)))
#print(c)

flag = False
k = 10**15
for i in range(len(c)):
    a = 1
    b = 1
    for j in range(len(c[i])):
        if c[i][j] == 0:
            a *= l[j]
        else:
            b *= l[j]
    k = min(k, a+b)
    

print(k-2)


### FIXED CODE ###

#%%
import math 

a, b, x = map(int, input().split())
if x == a*a*b:
    print(0)
elif x >= a*a*b/2:
    y = 2*(b-x/(a**2))
    ans = math.degrees(math.atan(a/y))
    print(90 - ans)
else:
    y = 2*(x/(a*b))
    ans = math.degrees(math.atan(y/b))
    print(90 - ans)
N,*B = map(int, open('0').read().split())
ans = [0]*N
for i in range(N):
  for j in range(len(B)-1,-1,-1):
    if B[j]==j+1:
      ans[N-1-i] = j+1
      B = B[:j]+B[j+1:]
      break
print('\n'.join(map(str,ans)))

### FIXED CODE ###

N,*B = map(int, open(0).read().split())
ans = [0]*N
for i in range(N):
  for j in range(len(B)-1,-1,-1):
    if B[j]==j+1:
      ans[N-1-i] = j+1
      B = B[:j]+B[j+1:]
      break
if B==[]:
  print('\n'.join(map(str,ans)))
else:
  print(-1)
s = input()
t = input()
alp = 'abcdefghijklmnopqrstuvwxyz'
s_li = []
for si in s:
    s_li.append(alp.find(si))
t_li = []
for ti in t:
    t_li.append(alp.find(ti))
if max(s_li) < max(t_li):
    print('Yes')
elif max(set(s_li)-set(t_li)) < max(set(t_li)-set(s_li)):
    print('Yes')
elif set(s_li) == set(t_li) and len(s_li) < len(t_li):
    print('Yes')
else:
    print('No')


### FIXED CODE ###

s = input()
t = input()
s_sorted = ''.join(sorted(s))
t_sorted = ''.join(sorted(t, reverse=True))
if s_sorted < t_sorted:
    print('Yes')
else:
    print('No')
i = list(map(int, input().split()))
n = i[0]
k = i[1]

if n >= 1 and n <= 100 and k >= 1 and k <= 100:
  if n > 2:
    if n % 2 == 1:
      if n / k >= 1:
        print("YES")
      elif n % k == 1:
        print("YES")
      else:
        print("NO")
    else:
      if n / k >= 2:
        print("YES")
      elif n % k == 0:
        print("YES")
      else:
        print("NO")
  else:
    print("NO")
else:

### FIXED CODE ###

i = list(map(int, input().split()))
n = i[0]
k = i[1]

if n >= 1 and k <= 100:
  if n == 1 and k == 1:
    print("YES")
  elif n > k:
    if n % 2 == 1:
      if int(n / k) >= 2:
        print("YES")
      elif int(n / k) == 1 and (int(n % k) == k - 1):
        print("YES")
      else:
        print("NO")
    else:
      if int(n / k) >= 2:
        print("YES")
      elif n % k == 0:
        print("YES")
      else:
        print("NO")
  else:
    print("NO")
n, m = map(int, input().split())
ab = [list(map(int, input().split())) for x in range(m)]

abmap = {}
for a, b in ab:
    atarget = abmap.get(a)
    if atarget == None:
        abmap[a] = []
    abmap[a].append(b)

    btarget = abmap.get(b)
    if btarget == None:
        abmap[b] = []
    abmap[b].append(a)

que = [[1, abmap[1], []]]
ends = []
while que:
    now, nextnodes, visited = que.pop()
    ends.append(visited)
    visited.append(now)
    for node in nextnodes:
        if node in visited:
            continue
        mvisited = visited[:]
        que.append([node, abmap[node], mvisited])

print(len(filter(lambda x: len(x) == n, ends)))


### FIXED CODE ###

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

abmap = {}
for a, b in ab:
    atarget = abmap.get(a)
    if atarget == None:
        abmap[a] = []
    abmap[a].append(b)

    btarget = abmap.get(b)
    if btarget == None:
        abmap[b] = []
    abmap[b].append(a)

que = [[1, abmap[1], []]]
ends = []
while que:
    now, nextnodes, visited = que.pop()
    ends.append(visited)
    visited.append(now)
    for node in nextnodes:
        if node in visited:
            continue
        mvisited = visited[:]
        que.append([node, abmap[node], mvisited])

print(len(list(filter(lambda x: len(x) == n, ends))))
N = int(input())
A = list(map(int, input().split()))
junb = []
inde = 0
basyo = 0
for touko in A:
    basyo = A.index(str(inde))
    junb.append.basyo
    inde += 1
print(str.junb)

### FIXED CODE ###

N = int(input())
kisuu = -(-N // 2)
print(kisuu / N)
X,Y=map(int,input.split())

if(Y%2 & 2*X<=Y<=4*X):
  print('Yes')
else:
  print('No')

### FIXED CODE ###

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

if(Y%2==0 and 2*X<=Y<=4*X):
  print('Yes')
else:
  print('No')
A = input()
op = ["+", "-"]
for bit in range(1 << 3):
    ans = A[0]
    for i in range(3):
        ans += op[bit & (1 << i)]+A[i+1]
    if eval(ans) == 7:
        print(ans+"=7")
        break


### FIXED CODE ###

A = input()
for bit in range(1 << 4):
    ans = int(A[0])
    res = [A[0]]
    for i in range(3):
        if bit & (1 << i):
            ans += int(A[i + 1])
            res.append("+")
            res.append(A[i+1])
        else:
            ans -= int(A[i + 1])
            res.append("-")
            res.append(A[i+1])
    if ans == 7:
        for i in range(7):
            print(res[i], end='')
        print("=7")
        break
S=input()
ans="Yes"
if all(a==b for a,b in zip(S,reversed(S))):
    if all(a==b for a,b in zip(S,reversed(S[:N//2]))):
            pass
    else:
        ans="No"
else:
    ans="No"
print(ans)


### FIXED CODE ###

S=input()
ans="Yes"
if all(a==b for a,b in zip(S,reversed(S))):
    if all(a==b for a,b in zip(S,reversed(S[:len(S)//2]))):
            pass
    else:
        ans="No"
else:
    ans="No"
print(ans)
H, W, N = input().split(" ")
H, W, N = int(H), int(W), int(N)
A = [input().split(" ") for i in range(N)]
A = [[int(l[0])-1, int(l[1])-1] for l in A]


black_num = [0 for i in range(10)]

import numpy as np
field = np.array([np.array([1 if [i, j] in A else 0 for j in range(W)]) for i in range(H)])

for h in range(H - 3 + 1):
    for w in range(W - 3 + 1):
        black_num[np.sum(field[h:h+3].T[w:w+3].T)] += 1
for i in black_num:
    print(i)

### FIXED CODE ###

H, W, N = input().split(" ")
H, W, N = int(H), int(W), int(N)
A = []
for i in range(N):
    A.append([int(j) for j in input().split(" ")])


import itertools
from collections import defaultdict, Counter

c = defaultdict(int)
for a, b in A:
    # そのセルを含む正方形の中心を記録
    for dx,dy in itertools.product([-1,0,1],repeat = 2):
        aa = a + dx
        bb = b + dy
        if 2 <= aa <= H-1 and 2 <= bb <= W-1:
            c[(aa,bb)] += 1
            
result = Counter(c.values())
result[0] = (H-2)*(W-2) - sum(result.values())
 
for j in range(10):
    print(result[j])
# At Coder 1
def calculate_reward_earning_per_competition(rank):
  # Get input for ranking of both competition
    switcher = { 
        1: 300000, 
        2: 200000 , 
        3: 100000, 
    }
   # 4th ranking and below will recieve nothing 
    return switcher.get(rank, 0)

# Execution
# Getting ranking of Coding Contest and Robot Manuever
x = int(input("Enter your Coding Contest Ranking: "))
y = int(input("Enter your Robot Manuever Ranking")) 
# Overall Winning Prize
total_winning_prize = calculate_reward_earning_per_competition(x) + calculate_reward_earning_per_competition(y)
if total_winning_prize == 600000:
  print(total_winning_prize + 400000)
else:
  print(total_winning_prize)   


### FIXED CODE ###

a, b = input().split(" ")
x = int(a)
y = int(b)

amt = 0
if x == 1:
    amt += 300000
elif x == 2:
    amt += 200000
elif x == 3:
    amt += 100000

if y == 1:
    amt += 300000
elif y == 2:
    amt += 200000
elif y == 3:
    amt += 100000

if x == 1 and y == 1:
    amt += 400000

print (amt)
n = int(raw_input())
s = raw_input()
aa = s.split(" ")
aaa = []
for i in range(n):
	aaa.append((i+1,int(aa[i])))

ctr = 0

for (a,b) in aaa:
	if a == b:
		aaa.remove((a,b))
	if (b,a) in aaa:
		aaa.remove((a,b))
		aaa.remove((b,a))
		ctr = ctr + 1

print(str(ctr))

### FIXED CODE ###

s = raw_input()
s2 = s[:4] + " " + s[4:]
print(s2)