Harryxun/stf_run huggingface dataset:
print("YES" if int("".join(input())) % 4 == 0 else "NO)

### FIXED CODE ###

x = "".join(input().split())
x = int(x)
if x % 4 == 0:
    print("YES")
else:
    print("NO")
h,w,a,b=map(int,input().split())

tmp=[0]*w
lista=[]
for i in range(h):
    lista.append([0]*w)
    
if a>w/2 or b>h/2:
    print("No")

elif h==1:
    for i in range(w-a):
        lista[0][a+i]=1
elif w==1:
    for i in range(h-b):
                lista[b+i][0]=1
else:  
    for i in range(w-a):
        lista[0][a+i]=1
    if b!=0:    
        for i in range(a):
            for j in range(h-b):
                lista[b+j][i]=1 
        for i in range(b):
            for i in range(w-a):
                lista[i][a+j]=1


print(lista)

### FIXED CODE ###

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

lista=[]

for i in range(h):
    lista.append([0]*w)

if (a>w/2)|(b>h/2):
    print("No")

else:
    if h==1:
        for i in range(w-a):
            lista[0][a+i]=1
    elif w==1:
        for i in range(h-b):
            lista[b+i][0]=1

    elif (a==0)&(b==0):
        lista=lista

    else:  
        for i in range(w-a):
            lista[0][a+i]=1
        
           
        if a==0:    
            for i in range(w):
                for j in range(b):
                    lista[j][i]=1 
        elif b==0:    
            for i in range(h):
                for j in range(w-a):
                    lista[i][j+a]=1                         
        else:    
            for i in range(a):
                for j in range(h-b):
                    lista[b+j][i]=1 
            for i in range(b):
                for j in range(w-a):
                    lista[i][a+j]=1


 

    for i in range(h):
        row = ""
        for j in range(w):
            row += str(lista[i][j])
        print(row)
S = int(input())
SS = S//500
SSS = (S%500)//5
print(1000*SS + 5*SSS)

### FIXED CODE ###

S=input()
if (S[2]==S[3]) and (S[4]==S[5]):
    print('Yes')
else:
    print('No')
N = int(input())
tree = [[] for _ in range(N + 1)]
for _ in range(N-1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)
c = [int(s) for s in input().split()]
c.sort(reverse=True)

anst = [0] * (N + 1)
anss = 0


def visit(a, prev):
    global anst, anss
    ans = 0
    for b in tree[a]:
        if b != prev:
            ci = visit(b, a)
            anss += ci
    ci = c.pop()
    anst[a] = ci
    return ci


visit(1, 1)
print(anss)
print(" ".join((str(i) for i in anst[1:])))


### FIXED CODE ###

import sys
sys.setrecursionlimit(200010)

N = int(input())
tree = [[] for _ in range(N + 1)]
for _ in range(N-1):
    a, b = map(int, input().split())
    tree[a].append(b)
    tree[b].append(a)
c = [int(s) for s in input().split()]
c.sort(reverse=True)

anst = [0] * (N + 1)
anss = 0


def visit(a, prev):
    global anst, anss
    ans = 0
    for b in tree[a]:
        if b != prev:
            ci = visit(b, a)
            anss += ci
    ci = c.pop()
    anst[a] = ci
    return ci


visit(1, 1)
print(anss)
print(" ".join((str(i) for i in anst[1:])))
# coding:utf-8
class Tree(object):
    def __init__(self, N):
        self.tree   = [[] for _ in range(N)]
        self.colors = [0  for _ in range(N)]

    def add_node(self, a, b):
        self.tree[a].append(b)
    # 二部グラフか判定する関数
    def is_bipartite_graph(self, v, color):
        self.colors[v] = color
        for to in self.tree[v]:
            if self.colors[to] == color:
                return False
            if self.colors[to] == 0:
                self.is_bipartite_graph(to, -color)
        return True
    
    def count_node(self, color):
        return self.colors.count(color)
    
if __name__ == "__main__":

    # input data
    N, M = map(int, input().split())
    tree = Tree(N)
    for _ in range(M):
        a, b = map(int, input().split())
        tree.add_node(a-1, b-1)
        tree.add_node(b-1, a-1)
    
    # tree dp
    is_bpr = tree.is_bipartite_graph(0, 1)
    if is_bpr:
        bla = tree.count_node(1)
        whi = N - bla
        print(bla*whi-M)
    else:
        print(int(N*(N-1)/2-M))



### FIXED CODE ###

# coding:utf-8
class Tree(object):
    def __init__(self, N):
        self.tree   = [[] for _ in range(N)]
        self.colors = [0  for _ in range(N)]

    def add_node(self, a, b):
        self.tree[a].append(b)
    # 二部グラフか判定する関数
    def is_bipartite_graph(self, v, color):
        self.colors[v] = color
        for to in self.tree[v]:
            if self.colors[to] == color:
                return False
            if self.colors[to] == 0 and not self.is_bipartite_graph(to, -color):
                return False
        return True
    
    def count_node(self, color):
        return self.colors.count(color)
    
if __name__ == "__main__":

    import sys
    sys.setrecursionlimit(200000)
    # input data
    N, M = map(int, input().split())
    tree = Tree(N)
    for _ in range(M):
        a, b = map(int, input().split())
        tree.add_node(a-1, b-1)
        tree.add_node(b-1, a-1)
    
    # tree dp
    is_bpr = tree.is_bipartite_graph(0, 1)
    if is_bpr:
        bla = tree.count_node(1)
        whi = N - bla
        print(bla*whi-M)
    else:
        print(int(N*(N-1)/2-M))
n=int(input())
cnt=0
for i in range(1,n+1):
  if len(i)%2==1:
    cnt+=1
print(cnt)

### FIXED CODE ###

n=int(input())
cnt=0
for i in range(1,n+1):
  if len(str(i))%2==1:
    cnt+=1
print(cnt)
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10

#solve
def solve():
    h, w = LI()
    a = SR(h)
    d = defaultdict(int)
    for i in range(h):
        for j in range(w):
            d[s[i][j]] += 1
    four = 0
    for i in d.values():
        if i & 1:
            print("No")
            return
        four |= i & 4 and not i & 3
    if four:
        print("Yes")
    else:
        print("No")
        

    return


#main
if __name__ == '__main__':
    solve()


### FIXED CODE ###

#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10

#solve
def solve():
    h, w = LI()
    x = h & 1 and w & 1
    a = SR(h)
    d = defaultdict(int)
    for i in range(h):
        for j in range(w):
            d[a[i][j]] += 1
    one = 0
    two = 0
    for i in d.values():
        one += i & 1
        two += (i >> 1) & 1
    if x:
        if one == 1:
            if h + w - 2 >= two << 1:
                print("Yes")
            else:
                print("No")
        else:
            print("No")
    else:
        if one:
            print("No")
        else:
            x = (h & 1) * (w >> 1) + (w & 1) * (h >> 1)
            if x:
                if x >= two:
                    print("Yes")
                else:
                    print("No")
            else:
                if two:
                    print("No")
                else:
                    print("Yes")

    return


#main
if __name__ == '__main__':
    solve()
K=int(input())
X,Y=map(int,input().split())

ispos_X,ispos_Y=True,True
if X<0:
  X=-X
  ispos_X=False
if Y<0:
  Y=-Y
  ispos_Y=False

if K%2==0 and (X+Y)%2==1:
  print(-1)
else:
  xx,yy=0,0
  vec_list=[]
  if K%2==0:
    while((X-xx)+(Y-yy)>2*K):
      if X-xx>K:
        xx+=K
        vec_list.append((K,0))
      elif Y-yy>K:
        yy+=K
        vec_list.append((0,K))
        
    #print(xx,yy,vec_list)
    diff_x=X-xx
    diff_y=Y-yy
    if diff_x+diff_y==K:
      vec_list.append((diff_x,diff_y))
    else:
      buf=2*K-diff_x-diff_y    
      vec_list.append((diff_x+buf//2,K-diff_x-buf//2))
      vec_list.append((-buf//2,K-buf//2))
      
  else:
    while((X-xx)+(Y-yy)>2*K):
      if X-xx>K:
        xx+=K
        vec_list.append((K,0))
      elif Y-yy>K:
        yy+=K
        vec_list.append((0,K))    
        
    #print(xx,yy,vec_list)
    diff_x=X-xx
    diff_y=Y-yy
    if diff_x+diff_y==K:
      vec_list.append((diff_x,diff_y))
    elif (diff_x+diff_y)%2==0:      
      buf=2*K-diff_x-diff_y
      if diff_x<K:
        vec_list.append((diff_x+buf//2,K-diff_x-buf//2))
        vec_list.append((-buf//2,K-buf//2))
      else:
        vec_list.append((K-diff_y-buf//2,diff_y+buf//2))
        vec_list.append((K-buf//2,-buf//2))
    elif diff_x+diff_y<K:
      xx+=diff_x
      yy+=-K+diff_x
      vec_list.append((diff_x,-K+diff_x))
      
      diff_x=X-xx
      diff_y=Y-yy      
      buf=2*K-diff_x-diff_y
      vec_list.append((diff_x+buf//2,K-diff_x-buf//2))
      vec_list.append((-buf//2,K-buf//2))
    else:
      if diff_x<K:
        xx+=diff_x
        yy+=K-diff_x
        vec_list.append((diff_x,K-diff_x))
      elif diff_y<K:
        xx+=K-diff_y
        yy+=diff_y        
        vec_list.append((K-diff_y,diff_y))

      diff_x=X-xx
      diff_y=Y-yy      
      buf=2*K-diff_x-diff_y
      vec_list.append((diff_x+buf//2,K-diff_x-buf//2))
      vec_list.append((-buf//2,K-buf//2))

  #print(vec_list)
  print(len(vec_list))
  pos_x,pos_y=0,0
  for x,y in vec_list:
    if ispos_X:
      pos_x+=x
    else:
      pos_x-=x
    if ispos_Y:
      pos_y+=y
    else:
      pos_y-=y
      
    print(pos_x,pos_y)

### FIXED CODE ###

A,B=map(int,input().split())
if (A+B)%2==0:
  print((A+B)//2)
else:
  print("IMPOSSIBLE")
A,B = map(int,input().split)
if A+B < A-B < A*B or A-B < A+B < A*B :ans = A*B
if A*B < A-B < A+B or A-B < A*B < A+B :ans = A+B
if A+B < A*B < A-B or A*B < A+B < A-B :ans = A-B
print(ans)

### FIXED CODE ###

A,B = map(int,input().split())
X = A + B
Y = A - B
Z = A * B
if X >= Y and X >= Z:
     print(X)
elif Y >= Z and Y >= X:
     print(Y)
elif Z >= X and Z >= Y:
     print(Z)
import itertools

[a,b,c] = [int(x) for x in input().split()]
[d,e,f] = [int(x) for x in input().split()]
[g,h,i] = [int(x) for x in input().split()]
N = int(input())
num_list = []
for i in N:
  n = int(input())
  num_list.append(n)
set_list = [{a,b,c},{d,e,f},{g,h,i},{a,d,g},{b,e,h},{c,f,i},{a,e,i}]
the_set = set(num_list) & set([a,b,c,d,e,f,g])
v = itertools.permutations(the_set,3)
for i in f:
  if i in set_list:
    print('Yes')
    break


### FIXED CODE ###

import itertools
import sys

[a,b,c] = [int(x) for x in input().split()]
[d,e,f] = [int(x) for x in input().split()]
[g,h,i] = [int(x) for x in input().split()]
N = int(input())
num_list = []
for j in range(N):
  n = int(input())
  num_list.append(n)

set_list = [{a,b,c},{d,e,f},{g,h,i},{a,d,g},{b,e,h},{c,f,i},{a,e,i},{c,e,g}]
the_set = set(num_list) & set([a,b,c,d,e,f,g,h,i])

v = itertools.permutations(the_set,3)
for k in v:
  if set(k) in set_list:
    print('Yes')
    sys.exit()
print('No')
import sys

sys.setrecursionlimit(100000)

import numpy as np


def main():
    n_num, m_num = map(int, input().split())
    road = np.zeros((n_num, n_num), dtype='int32')

    for _ in range(m_num):
        a, b = map(int, input().split())
        if a > b:
            a, b = b, a
        road[a-1][b-1] = 1

    city_info = np.zeros(n_num, dtype='int32')
    land_city = 0

    def move(a, b):
        if a > b:
            a, b = b, a
        if road[a-1][b-1] == 1:
            return 1
        else:
            return 0

    def recr(c):
        city_info[c] = 1
        for n in range(n_num):
            if city_info[n] == 0:
                if move(c, n) == 1:
                    recr(n)

    for n in range(n_num):
        if city_info[n] == 0:
            land_city += 1
            recr(n)

    print(land_city - 1)


if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys

sys.setrecursionlimit(100000)

import numpy as np


def main():
    n_num, m_num = map(int, input().split())
    # road = np.zeros((n_num, n_num), dtype='int32')
    c_map = []
    for _ in range(n_num):
        c_map.append([])
    # print(c_map)

    for _ in range(m_num):
        a, b = map(int, input().split())
        if a > b:
            a, b = b, a
        # road[a-1][b-1] = 1
        c_map[a-1].append(b-1)
        c_map[b-1].append(a-1)
    # print(c_map)

    city_info = np.zeros(n_num, dtype='int32')
    land_city = 0

    def move(a, b):
        if a in c_map[b]:
            return 1
        else:
            return 0

    def recr(c):
        city_info[c] = 1
        for n in c_map[c]:
            if city_info[n] == 0:
                if move(c, n) == 1:
                    recr(n)

    for n in range(n_num):
        if city_info[n] == 0:
            land_city += 1
            recr(n)
    # print(c_map)
    # print(city_info)
    print(land_city - 1)


if __name__ == '__main__':
    main()
x=[input().split(' ')]
if x[0]==x[1]:
  print('=')
elif:
  tmp=x[0]
  x.sort()
  if x[0]==tmp:
    print('<')
  else:
    print('>')


### FIXED CODE ###

x=[i for i in input().split(' ')]
if x[0]==x[1]:
  print('=')
else:
  tmp=x[0]
  x.sort()
  if x[0]==tmp:
    print('<')
  else:
    print('>')
X, Y, Z = input().split()
print(f'{Z} {X} {Y}')

### FIXED CODE ###

A, B, C = input().split()
print(C, A, B)
import math

X = [int(x) for x in input().split()]

v = math.gcd(X[0], X[1])
j = X[0] / v
p = int(X[1] * j)

print(p)

### FIXED CODE ###

import fractions

X = [int(x) for x in input().split()]

v = fractions.gcd(X[0], X[1])
j = X[0] / v
p = int(X[1] * j)

print(p)
import sys
sys.setrecursionlimit(2000000)

N = int(input())
NUMS = [int(input()) for _ in range(N)]
NUMS = list(set(NUMS))

def gcd(num1, num2):
    if num2 == 0:
        return num1
    else:
        return gcd(num2, num1 % num2)


res = []
for num1 in NUMS:
    for num2 in NUMS:
        if num1 == num2:
            continue
        res.append(int(num1  * num2 / gcd(num1, num2)))

print(max(res))

### FIXED CODE ###

import sys
import fractions
sys.setrecursionlimit(200000000)

N = int(input())
NUMS = [int(input()) for _ in range(N)]
NUMS = list(set(NUMS))

def gcd(num1, num2):
    if num2 == 0:
        return num1
    else:
        return gcd(num2, num1 % num2)


res = NUMS[0]
for num in NUMS[1:]:
    res = res * num // fractions.gcd(res, num)

print(int(res))
# import bisect
# import copy
# import fractions
# import math
#import numpy as np
# from collections import Counter, deque
# from itertools import accumulate,permutations, combinations,combinations_with_replacement,product

def resolve():
    n=int(input())
    A=np.array(list(map(int,input().split())))

    cnt=0
    while all(i%2==0 for i in A):
        A = A//2
        cnt+=1
    print(cnt)



resolve()


### FIXED CODE ###

# import bisect
# import copy
# import fractions
# import math
import numpy as np
# from collections import Counter, deque
# from itertools import accumulate,permutations, combinations,combinations_with_replacement,product

def resolve():
    n=int(input())
    A=np.array(list(map(int,input().split())))

    cnt=0
    while all(i%2==0 for i in A):
        A = A//2
        cnt+=1
    print(cnt)



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

a = [list(input()) for i in range(n)]

h = []
l = []
co = 0
for i in range(n):
    co = 0
    for j in range(m):
        if a[i][j] == "#":
            co = 1
    if co == 0:
        l.append(i)
for i in range(m):
    co = 0
    for j in range(n):
        if a[j][i] == "#":
            co = 1
    if co == 0:
        h.append(i)

for i in range(len(l)):
    a.pop(l.pop())

for i in range(len(h)):
    p = h.pop()
    for j in range(len(a)):
        a[j].pop(p)

for i in range(len(a)):
    print("".join(a[i]))

### FIXED CODE ###

a = int(input())
b = int(input())

if a > b:
  print("GREATER")
elif a == b:
  print("EQUAL")
else:
  print("LESS")
size = int(input())
a,b = list(map(int,input().split()))
ans = ""
for i in range(size):
  ans += a[i]
  ans += b[i]
print(ans)


### FIXED CODE ###

size = int(input())
a,b = list(map(str,input().split()))
ans = ""
for i in range(size):
  ans += a[i]
  ans += b[i]
print(ans)
As=list(input().split())
if As.sum() >= 22:
  print("bust")
else:
  print("win")

### FIXED CODE ###

As=list(map(int,input().split()))
if sum(As) >= 22:
  print("bust")
else:
  print("win")
a,b = map(int,input())
if a*b%2==0:
  print("Even")
else:
  print("Odd")

### FIXED CODE ###

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

if(a*b)%2 == 0:
  print("Even")
else:
  print("Odd")
def main():
    N = input()
    S = str(N)
    S = S[::-1]

    odd = 0
    even = 0

    for i in range(len(S)):
        if (i + 1) % 2 == 0:
            even += int(S[i])
        else:
            odd += int(S[i])
    print(even, odd)

if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    N, A, B = map(int, input().split())
    ans = 0

    if A > B:
        ans = 0
    else:
        if N == 1:
            if A != B:
                ans = 0
            else:
                ans = 1
        elif N == 2:
            ans = 1
        else:
            ans = (B - A)*(N - 2) + 1

    print(ans)
    
if __name__ == "__main__":
    main()
# -*- coding:utf-8 -*-
n=int(raw_input())
for i in range(0,n):
    a,b,c,d,e,f,g,h=map(float,raw_input().split(" "))
    t=(d-b)/(c-a)
    y=(h-f)/(g-e)
    if y==t or y==-t:
        print "YES"
    else:
        print "NO",

### FIXED CODE ###

n = int(raw_input())
for i in range(n):
    x1, y1, x2, y2, x3, y3, x4, y4 = map(float, raw_input().split())
    print "YES" if abs(((y2-y1)*(x4-x3) - (x2-x1)*(y4-y3))) < 1e-10 else "NO"
S=input()
cnt=0
lis=[]
for i in range(len(S)):
    if S[i]=='A'or S[i]=='C' or S[i]=='G' or S[i]=='T':
        cnt+=1
        lis.append(cnt)
    else:
        cnt=0
print(max(lis))

### FIXED CODE ###

S=input()
cnt=0
lis=[0]
for i in range(len(S)):
    if S[i]=='A'or S[i]=='C' or S[i]=='G' or S[i]=='T':
        cnt+=1
        lis.append(cnt)
    else:
        cnt=0
print(max(lis))
N,A = map(int, input()) for i in range(2)
print(N*N-A)

### FIXED CODE ###

N = int(input())
A = int(input())
print(N*N-A)
N = input()
if len([a for a in input().rstrip().split() if a % 2]) % 2:
    print('NO')
else:
    print('YES')

### FIXED CODE ###

N = input()
if len([a for a in input().rstrip().split() if int(a) % 2]) % 2:
    print('NO')
else:
    print('YES')
h,w=map(int,input().split())
alp=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
l=[]
for i in range(h):
    a=list(map(str,input().split()))
    l.append(a)
for j in range(w):
    for k in range(h):
        if l[j][k]=='snuke':
            print(str(alp[j])+str(k+1))
print(l)

### FIXED CODE ###

h,w=map(int,input().split())
s=[input().split() for i in range(h)]
al=[chr(i) for i in range(65,65+26)]
for i in range(h):
    if 'snuke' in s[i]:
        print(al[s[i].index('snuke')]+str(i+1))
import collections

K = int(input())

a = []
for i in range(1,K+1):
    for j in range(1, K+1):
        a.append(gcd(i,j))
        
col = collections.Counter(a)

sum = 0
for k in range(1, K+1):
    for key, value in col.items():
         sum += gcd(k, key) * value
print(sum)

### FIXED CODE ###

import collections

def gcd(a,b):
    if a < b:
        a, b = b, a
    q = a // b
    r = a - q * b
    if r == 0:
        return b
    else:
        return gcd(b,r)

K = int(input())

a = []

for i in range(1,K+1):
    for j in range(1, K+1):
        a.append(gcd(i,j))
        
col = collections.Counter(a)

sum = 0
for k in range(1, K+1):
    for key, value in col.items():
         sum += gcd(k, key) * value
print(sum)
n,m=map(int,input().split())
l=[]
for i in range(n):
  a,b=map(int,input().split())
  l.append([a,b])
l.sort()
l.append([0,0])
ans=0
k=[]
j=0
for i in range(1,m+1):
  while j<=n and l[j][0]<=i:
    k.append(l[j][1])
    j+=1
  ans+=max(k)
  k.remove(max(k))
print(ans)

### FIXED CODE ###

import heapq
n,m=map(int,input().split())
l=[]
for i in range(n):
  a,b=map(int,input().split())
  l.append([a,b])
l.sort()
l.append([0,0])
ans=0
k=[]
j=0
for i in range(1,m+1):
  while j<=n and l[j][0]<=i:
    heapq.heappush(k, -1*l[j][1])
    j+=1
  if len(k)!=0:
  	ans+=-1*k[0]
  	heapq.heappop(k)
print(ans)
import math
L = [input() for _ in range(5)]
lm = 9
v = 0
for l in L:
  if int(l[-1])<lm and l[-1]!='0':
    lm = int(l[-1])
    v = int(l)
t = 0
L.remove(str(v))
for l in L:
  t += math.ceil(int(l)/10)*10
print(t + v)

### FIXED CODE ###

import math
L = [input() for _ in range(5)]
lm = int(L[0][-1])
v = int(L[0])
for l in L:
  if int(l[-1])<lm and l[-1]!='0':
    lm = int(l[-1])
    v = int(l)
t = 0
L.remove(str(v))
for l in L:
  t += math.ceil(int(l)/10)*10
print(t + v)
Alp =[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z]*2
N = int(input())
S = list(input())
for i in range(len(S)):
  Anum = Alp.index(S[i])
  S.replace(S[i],Alp[Anum+N])
print("".join(S))


### FIXED CODE ###

Alp =["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]*2
N = int(input())
S = list(input())
for i in range(len(S)):
	Anum = Alp.index(S[i])
	S[i] = Alp[Anum+N]
print("".join(S))
n=int(input())
flag=False
for i in range(n//4+1):
    for j in range(n//7+1):
        sum=4*i+7*j
        if sum==n:
            flag=True
print('Yes' if flag else'No')
    

### FIXED CODE ###

n,k=map(int,input().split())
print(0 if n%k==0 else 1)
N,K = map(int,input().split())
S = input()
S[K-1] = S[K-1].lower()
print(S)

### FIXED CODE ###

N,K = map(int,input().split())
S = input()
S[K-1].lower()
print(S[:K-1]+ S[K-1].lower() + S[K:])
N = int(input())
number = "Three"
S = input().split()
for i in range(N):
  If S[i] == "Y":
    number = "Four"
    break

print(number)
    

  

### FIXED CODE ###

N = int(input())
number = "Three"
S = input().split()

for i in range(N):
  if S[i] == "Y":
    number = "Four"
    break

print(number)
from math import gcd
A,B = map(int,input().split())

#最小公倍数
def lcm(x,y):
    return (x*y//gcd(x,y))

print(lcm(A,B))


### FIXED CODE ###

#from math import gcd
from fractions import gcd
A,B = map(int,input().split())

#最小公倍数
def lcm(x,y):
    return (x*y//gcd(x,y))

print(lcm(A,B))
import numpy as np
import math

a,b = map(int,input().split())
def cf(x1,x2):
    cf = []
    for i in range(1,int(np.sqrt(max(x1,x2))+2)):
        if x1 % i == 0 and x2 % i == 0:
            cf.append(i)
    return cf

def prime(num):
  for p in range(2, int(np.sqrt(num)+2)):
    if num % p == 0:
      return False
  return True

lis = cf(a,b)
for k,l in enumerate(lis):
  if prime(l) == False:
    lis[k] = -1
s = set(lis) - set([-1])
s.add(math.gcd(a,b))
print(len(s))

### FIXED CODE ###

import numpy as np


a,b = map(int,input().split())
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

lisa = prime_factorize(a)
lisb = prime_factorize(b)
lis = set(lisa) & set(lisb)
lis.add(1)
lis = sorted(list(lis))
devil = (max(a,b)/lis[-1])
if len(prime_factorize(devil)) == 1:
  if min(a,b) % devil == 0:
    lis.append(devil)
print(len(set(lis)))