Harryxun/stf_run huggingface dataset:
import math
X = int(input())


def fif_root(arg):
    def root():
        return math.floor(math.pow(x,1/5)*pow(10,10))/pow(10,10)
    return list(map(lambda x: root(x), arg))

def check_integer(arg):
    return list(map(lambda x: x.is_integer(), arg))

a = 0
while (A:= math.pow(a, 5))-math.pow(a-1, 5) <= X:
    #a,-aの時それぞれの5乗根を計算する。
    root = fif_root([abs(X-A), X+A])
    if True in (c := check_integer(root)):
        idx = c.index(True)
        b = int(root[idx])
        if idx == 1:
            a, b = -a, -b
        else:
            if X - A >= 0:
                b = -b
        print(a, b)
        break
    a += 1


### FIXED CODE ###

import math
X = int(input())


def fif_root(arg):
    def root(x):
        return math.floor(math.pow(x,1/5)*pow(10,10))/pow(10,10)
    return list(map(lambda x: root(x), arg))

def check_integer(arg):
    return list(map(lambda x: x.is_integer(), arg))

a = 0
while (A:= math.pow(a, 5))-math.pow(a-1, 5) <= X:
    #a,-aの時それぞれの5乗根を計算する。
    root = fif_root([abs(X-A), X+A])
    if True in (c := check_integer(root)):
        idx = c.index(True)
        b = int(root[idx])
        if idx == 1:
            a, b = -a, -b
        else:
            if X - A >= 0:
                b = -b
        print(a, b)
        break
    a += 1
from math import gcd

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

A,B,K = map(int, input().split())

gcd_num = gcd(A,B)

divisor = make_divisors(gcd_num)

print(divisor[-K])

### FIXED CODE ###

def gcd(x,y):
    if x%y==0:
        return y
    else:
        return gcd(y, x%y)

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

A,B,K = map(int, input().split())

gcd_num = gcd(A,B)

divisor = make_divisors(gcd_num)

print(divisor[-K])
import math

l,r=map(int, input().split())

if r-l > 2019:
    s=list(range(0, 2019))
else:
    s=set()
    for i in range(l, r+1):
        s.add(i%2019)
    s=list(s)

ans=math.inf
for i in range(len(s)):
    for j in range(i+1, len(s)):
        ans=min(ans, (s[i]*s[j])%2019)

print(ans)


### FIXED CODE ###

l,r=map(int, input().split())

if r-l > 2019:
    s=list(range(0, 2019))
else:
    s=set()
    for i in range(l, r+1):
        s.add(i%2019)
    s=list(s)

ans=float('inf')
for i in range(len(s)):
    for j in range(i+1, len(s)):
        ans=min(ans, (s[i]*s[j])%2019)

print(ans)
a, b = map(int, input().split())
def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)
def lcm(a, b):
    return (a * b) // math.gcd(a, b)
print(lcm(a, b))

### FIXED CODE ###

a, b = map(int, input().split())
def gcd(a, b):
    while b:
        a, b= b, a%b
    return a
def lcm(a, b):
    return (a * b) // gcd(a, b)
print(lcm(a, b))
a = input

b = ((a-a/2)/a)

print(b)

### FIXED CODE ###

N = int(input())
 
ans = 0
for i in range(1, N+1):
    if i % 2 == 1:
        ans += 1
print(ans/N)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: 	D_fix_4
# CreatedDate:  2020-07-20 00:18:24 +0900
# LastModified: 2020-07-20 00:26:33 +0900
#


import os
import sys
# import numpy as np
# import pandas as pd


def main():
    n = int(input())
    A = sorted(map(int, input().split()))
    ans = [1]*n
    for i, a in enumerate(A):
        if ans[i] == 0:
            continue
        for j in range(i+1, n):
            if A[j]%a == 0:
                ans[j] = 0
    if A[0] == A[1]:
        ans[0] = 0
    print(sum(ans))

if __name__ == "__main__":
    main()


### FIXED CODE ###

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: 	D_fix_3
# CreatedDate:  2020-06-19 15:09:52 +0900
# LastModified: 2020-06-19 15:27:30 +0900
#


import os
import sys
# import numpy as np
# import pandas as pd


def main():
    _ = int(input())
    a_s = list(map(int, input().split()))
    m = max(a_s)+1
    cnt = [0 for _ in range(m)]

    for a in a_s:
        if cnt[a] != 0:
            cnt[a] = 2
            continue
        for n in range(a, m, a):
            cnt[n] += 1

    print(sum(cnt[a] for a in a_s if cnt[a]==1))


if __name__ == "__main__":
    main()
def ABC_86_B():
    T=list(input())
    for i in range(len(T)):
        if T[i] == '?':
            if i==0 and T[0]=='P':
                i=i
            elif i == 0 and T[0]=='D':
                i=i
            elif i == 0 and T[0]=='?' and T[1]=='D':
                T[0] = 'P'
            elif i == 0 and T[0]=='?' and T[1]=='P':
                T[0] = 'D'
            elif T[i-1] == 'P':
                T[i]='D'
            elif T[i-1] == 'D':
                T[i]='P'

    print(''.join(T))

if __name__ == '__main__':

    ABC_86_B()

### FIXED CODE ###

def ABC_86_B():
    T=list(input())
    for i in range(len(T)):
        if T[i] == '?':
            T[i]='D'

    print(''.join(T))

if __name__ == '__main__':

    ABC_86_B()
S=input()
S=int(S)
h=S/3600
h=int(h)
m=(S-3600*h)/60
m=int(m)
s=S-h*3600-m*60
s=int(s)
print(h:m:s)

### FIXED CODE ###

S=input()
S=int(S)
h=S/3600
h=int(h)
m=(S-3600*h)/60
m=int(m)
s=S-h*3600-m*60
s=int(s)
h=str(h)
m=str(m)
s=str(s)
print(h+':'+m+':'+s)
N = int(input())
A = list(map(int, input().split()))


S = sorted(A)
MAXS = max(A)

for i in range(N):
    if A[i] == MAXS:
        print(S[-2])
    else:
        print(S[-1])


### FIXED CODE ###

# N = int(input())
# A = list(map(int, input().split()))
# 
# S = sorted(A)
# MAXS = max(A)
# 
# for i in range(N):
#     if A[i] == MAXS:
#         print(S[-2])
#     else:
#         print(S[-1])
# 


n = int(input())
a = list()
for i in range(n):
    a.append(int(input()))
c = a.index(max(a))
m = max(a)
a.sort()
d = a[-2]
for i in range(n):
    if i == c:
        print(d)
    else:
        print(m)
N, M=map(int, input().split())
A=list(map(int, input().split()))
BC=[]
for _ in range(M):
    BC.append(tuple(map(int, input().split())))
A=sorted(A)
BC=sorted(BC, key=lambda val:val[1], reverse=True)
print(N,M,A,BC)


change=[]
for bc in BC:
    for _ in range(bc[0]):
        change.append(bc[1])
print(change)

for i in range(len(change)):
    if A[i]>change[i]:
        answer = sum(change[:i]) + sum(A[i:])
        print(answer)
        break
else:
    answer=sum(change[:i+1])+sum(A[i+1:])
    print(answer)


### FIXED CODE ###

import copy

N, M=map(int, input().split())
A=list(map(int, input().split()))
BC=[]
for _ in range(M):
    BC.append(tuple(map(int, input().split())))
A=sorted(A)
BC=sorted(BC, key=lambda val:val[1], reverse=True)
#print(N,M,A,BC)


change=[]
for bc in BC:
    for _ in range(bc[0]):
        change.append(bc[1])
    if len(change)>=N:
        break
#print(change)

if A[0]>=change[0]:
    print(sum(A))
else:
    for i in range(min(N,len(change))):
        if A[i]>change[i]:
            answer = sum(change[:i]) + sum(A[i:])
            print(answer)
            break
    else:
        answer=sum(change[:i+1])+sum(A[i+1:])
        print(answer)
s = [input(),input(),input()]
print(s[2], s[0], s[1])

### FIXED CODE ###

a,b,c=map(int,input().split())
print(c, a, b)
n = int(input())
x_list = list(map(int, input().split()))
ans_list = [sum([(x - p) ** 2 for x in x_list]) for p in range(min(x_list), max(x_list)) + 1]
print(sorted(ans_list)[0])

### FIXED CODE ###

n = int(input())
x_list = list(map(int, input().split()))
ans_list = [sum([(x - p) ** 2 for x in x_list]) for p in range(min(x_list), max(x_list) + 1)]
print(sorted(ans_list)[0])
a=input()
x=abs(int(a[0])*100+int(a[1])*10+int(a[2])-753)
for i in range(i-2)
if abs(int(a[i])*100+int(a[i+1])*10+int(a[i+2])-753)<=x:
    x=abs(int(a[i])*100+int(a[i+1])*10+int(a[i+2])-753)

### FIXED CODE ###

a=input()
x=abs(int(a[0])*100+int(a[1])*10+int(a[2])-753)
for i in range(len(a)-2):
    if abs(int(a[i])*100+int(a[i+1])*10+int(a[i+2])-753)<=x:
        x=abs(int(a[i])*100+int(a[i+1])*10+int(a[i+2])-753)
print(x)
import numpy as np
import math

A,B,C,D = map(int, input().split())

c = (B  - B%C) / B - ((A-1)  - (A-1)%C)/C
d = (B  - B%D) / B - ((A-1)  - (A-1)%D)/D

CD = (C * D  - (C * D % math.gcd(C, D))) / math.gcd(C, D)
cd = (B  - B%CD) / B - ((A-1)  - (A-1)%CD)/CD

ans = B - (A-1) - (c + d - cd)
ans = int(ans)

print(ans)

### FIXED CODE ###

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

A,B,C,D = map(int, input().split())

c = B//C - (A-1)//C
d = B//D - (A-1)//D

CD = C * D // gcd(C, D)
cd = B//CD - (A-1)//CD

ans = B - (A-1) - (c + d - cd)
print(ans)
A = list(map(int,input().split()))
print(SUM(A) - MAX(A))

### FIXED CODE ###

A = list(map(int,input().split()))
print(sum(A)-max(A))
N = int(input())
a = N % 1000
b = a!= 0 ? 1000 - a : 0
print(b)

### FIXED CODE ###

N = int(input())
a = N % 1000
b = 1000 - a if a!=0 else 0
print(b)
A, B, C, X = map(int, input().split())
I = 0
for i in range(A + 1):
	for j in range(B + 1):
		for k in range(C + 1):
			if (500 * i) + (100 * j) + (50 * k) == X:
				I++
print(I)


### FIXED CODE ###

A=int(input())
B=int(input())
C=int(input())
X=int(input())

ans = 0
for a in range(A + 1):
    for b in range(B + 1):
        for c in range(C + 1):
            if 500 * a + 100 * b + 50 * c == X:
                ans += 1

print(ans)
def main():
  import fractions
  import math

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

  if a>b:
    a,b = b,a
  
  d = [1]
  num = 2

  while num <= min(a,b):
    if a%num == 0 and b%num == 0:
      d.append(num)
      while a%num == 0 and a>1:
        a = a//num
      while b%num == 0 and b>1:
        b = b//num
    num+=1
  
  print(len(d))

if __name__ == "__main__":
  main()


### FIXED CODE ###

n = int(input())

print(0.5 if n%2==0 else (n//2+1)/n)
b = input()
if(b == "A"):
  print("T")
elif(b == "T"):
  print("A")
elif(b == "C"):
  print("G"):
else:
  print("C")

### FIXED CODE ###

b = input()
if(b == "A"):
  print("T")
elif(b == "T"):
  print("A")
elif(b == "C"):
  print("G")
else:
  print("C")
def cin():  return list(map(int,input().split()))

def gcd_(a, b):
    if a < b:  a, b = b, a
    if b == 0:  return a
    return gcd_(b, a % b)

def gcd(l):
    ans = 0
    for i in l:  ans = gcd_(ans, i)
    return ans

def lcm_(x,y):
    return (x * y) // gcd_(x, y)

def lcm(l):
    ans = l[0]
    for i in l:  ans = lcm_(ans, i)
    return ans

N = cin()[0]
v = cin()
lc = lcm(v)
ans = 0
INF = 10 ** 9 + 7
for i in range(N):
    ans += lc / v[i]
    ans %= INF
print(int(ans))

### FIXED CODE ###

def cin():  return list(map(int,input().split()))

def gcd_(a, b):
    if a < b:  a, b = b, a
    if b == 0:  return a
    return gcd_(b, a % b)

def gcd(l):
    ans = 0
    for i in l:  ans = gcd_(ans, i)
    return ans

def lcm_(x,y):
    return (x * y) // gcd_(x, y)

def lcm(l):
    ans = l[0]
    for i in l:  ans = lcm_(ans, i)
    return ans

N = cin()[0]
v = cin()
lc = lcm(v)
ans = 0
INF = 10 ** 9 + 7
lc %= INF
for i in range(N):
    ans += lc * pow(v[i], INF - 2, INF)
    ans %= INF
print(int(ans))
N=int(input())
ABC=[]
for _ in range(N):
    ABC.append(list(map(int,input().split())))
MAXlist=[]

def dynam(n):
    if n>1:
        a=max(dynam(n-1)[1]+ABC[n-1][0],
              dynam(n-1)[2]+ABC[n-1][0])
        b=max(dynam(n-1)[0]+ABC[n-1][1],
              dynam(n-1)[2]+ABC[n-1][1])
        c=max(dynam(n-1)[0]+ABC[n-1][2],
              dynam(n-1)[1]+ABC[n-1][2])
        return (a,b,c)
    return tuple(ABC[0])
print(max(dynam(N)))

### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000000)
N=int(input())
ABC=[]
for _ in range(N):
    ABC.append(list(map(int,input().split())))
from functools import lru_cache
@lru_cache(maxsize=None)
def dynam(n):
    if n>1:
        a=max(dynam(n-1)[1]+ABC[n-1][0],
              dynam(n-1)[2]+ABC[n-1][0])
        b=max(dynam(n-1)[0]+ABC[n-1][1],
              dynam(n-1)[2]+ABC[n-1][1])
        c=max(dynam(n-1)[0]+ABC[n-1][2],
              dynam(n-1)[1]+ABC[n-1][2])
        return (a,b,c)
    return tuple(ABC[0])
print(max(dynam(N)))
N = int(input())
A = list(map(int, input().split()))

a=A[0]; c=1; i=1; w=0
def f(x):
    return A[x], x+1

while True:
    if w==0:
        if A[i]==a:
            a,i=f(i)
        elif A[i] > a:
            w=1; a,i=f(i)
        else:
            w=-1; f(i)
    elif w>0:
        if A[i]>=a:
            a,i=f(i)
        else:
            c+=1; a,i=f(i); w=0
    elif w<0:
        if A[i]<=a:
            a,i=f(i)
        else:
            c+=1; a,i=f(); w=0
    if i==N:
        break

print(c)


### FIXED CODE ###

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

c = 1; w = 0
for i in range(N-1):
    if w == 0:
        if A[i] < A[i+1]:
            w = 1
        elif A[i] > A[i+1]:
            w = -1
    elif (w > 0 and A[i] > A[i+1]) or (w < 0 and A[i] < A[i+1]):
         w = 0
         c += 1

print(c)
N = int(input())
X = [int(x) for x in input().split()]
hp = []
dis = 0
for i in range(X[0],X[N-1] + 1):
  hp.append(dis)
  dis = 0
  for j in X:
    dis += (i - j) ** 2
hp.remove(0)
print(min(hp))

### FIXED CODE ###

N = int(input())
X = [int(x) for x in input().split()]
hp = []
dis = 0

for i in range(min(X), max(X) + 1):
  hp.append(dis)
  dis = 0
  for j in X:
    dis += (i - j) ** 2
if len(hp) == 1:
  print(0)
else:
  hp.remove(0)
  print(min(hp))
A,B,K=map(int,input().split())
nums = list(range(A,B+1))
result = []
L = min(B-A+1,K)
for i in range(L):
    if nums[i] not in result:
        result.append(nums[i])
nums.sort(reverse=True)
for j in range(L):
    if nums[j] not in result:
        result.append(nums[j])
result.sort()
for x in result:
    print(x)

### FIXED CODE ###

A,B,K=map(int,input().split())
result = []
L = min(B-A+1,K)
for i in range(A,A+L):
    if i not in result:
        result.append(i)
for j in range(B,B-L,-1):
    if j not in result:
        result.append(j)
result.sort()
for x in result:
    print(x)
H,W = map(int, input().split())
A = []
for _ in range(H):
    v = 0
    for w, x in zip(range(W), input()):
        if x == "#":
            v |= 1 << w
    A += [ v ]

import numpy as np


A = np.array(A)
WK = np.zeros(A.shape)
MASK = pow(2, W) - 1
MASKSUM = MASK * H
i = 0
while True:
    if np.sum(A) == MASKSUM:
        break
    WK = 0+A
    A[:-1] |= WK[1:]
    A[1:] |= WK[:-1]
    A |= ((WK << 1)&MASK) | (WK >> 1)
    i += 1

print(i)


### FIXED CODE ###

from collections import deque
h, w = map(int, input().split())
que = deque()
data = []

for ln in range(h):
    line = list(input().rstrip())
    data.append(line)
    for r, letter in enumerate(line):
        if letter == '#':
            que.append((ln, r))

count = 0
while len(que) > 0:
    count += 1
    next = deque()
    while len(que) > 0:
        row, col = que.popleft()
        for r, c in [(row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)]:
            if 0 <= r < h and 0 <= c < w and data[r][c] == '.':
                next.append((r, c))
                data[r][c] = '#'
    que = next

print(count - 1)
n=int(input())
s=input()
a=0
b=0
for i in range(n-1):
  if s[i]=="I":
    a=a+1
    if a>b:
      b=a
  else:
    a=a-1
print(b)

### FIXED CODE ###

a,b,c,d=map(int,input().split())
print(max(a*b,c*d))
def is_circle(current_list, rest_list):
    if rest_list == []:
        if (current_list[-1] ^ current_list[0]) == current_list[1]:
            return True
        else:
            return False
    if len(current_list) == 1:
        for num in rest_list:
            current_list.append(num)
            rest_list.remove(num)
            if is_circle(current_list, rest_list):
                return True
        return False

    next_int = current_list[-1] ^ current_list[-2]
    if next_int in input_list:
        current_list.append(next_int)
        rest_list.remove(next_int)
        return is_circle(current_list, rest_list)
    else:
        return False
        

n = int(input())
input_list = [int(i) for i in input().split(' ')]

if is_circle([input_list[0]], input_list[1:]):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

import collections 

n = int(input())
input_list = [int(i) for i in input().split(' ')]

counter = collections.Counter(input_list)


unique_list = list(counter.keys())
counts = list(counter.values())

if (all(num == 0 for num in unique_list)):
    print('Yes')
else:
    if n % 3 == 0:
        zero_count = counter[0] 
        if zero_count == n / 3 and len(unique_list) == 2:
            print('Yes')
        else: 
            if len(unique_list) != 3:
                print('No')
            elif (unique_list[0] ^ unique_list[1] == unique_list[2]):
                if (all(counts[0] == num for num in counts)):
                    print('Yes')
                else:
                    print('No')
            else:
                print('No')
    else:
        print('No')
n = int(input())
s = [int(input()) for _ in range(n)]
ans = set()

for i in s:
    ans.add(i)

print(len(ans))


### FIXED CODE ###

n = int(input())
s = [input() for _ in range(n)]
ans = set()

for i in s:
    ans.add(i)

print(len(ans))
# coding=UTF-8
from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
input = sys.stdin.readline


def ev(n):
    return 0.5*(n+1)


def main():
    n, k = map(int, input().split())
    p = list(map(int, input().split()))

    s = []

    p_ev = list(map(ev, p))

    for i in range(1, n+1):
        s.append(sum(p_ev[:i]))

    ans = []

    for i in range(n - k):
        ans.append(s[i+k]-s[i])
    print(max(ans))


if __name__ == '__main__':
    main()


### FIXED CODE ###

# coding=UTF-8
from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
input = sys.stdin.readline


def ev(n):
    return 0.5*(n+1)


def main():
    n, k = map(int, input().split())
    p = list(map(int, input().split()))

    p_ev = list(map(ev, p))

    s = np.cumsum(p_ev)
    s = np.insert(s, 0, 0)

    ans = []

    for i in range(n - k+1):
        ans.append(s[i + k] - s[i])

    print(max(ans))


if __name__ == '__main__':
    main()
def main():
    x, n = (int(i) for i in input().split())
    if n > 0:
        p = [int(i) for i in input().split()]
    else:
        p = []

    mask = [0] * 101 
    for pe in p:
        mask[pe] = 1

    b, e = x, x
    while True:
        if mask[b] == 0 or mask[e] == 0:
            break
        b -= 1
        e += 1

    if mask[b] == 0:
        print(b)
    else:
        print(e)



main()


### FIXED CODE ###

def main():
    # x in [1, 100]
    # n in [0, 100]
    # p_i in [1, 100] 
    x, n = (int(i) for i in input().split())
    if n > 0:
        p = set(int(i) for i in input().split())
    else:
        p = set() 

    b, e = x, x
    while b in p and e in p:
        b -= 1
        e += 1

    if b not in p:
        print(b)
    else:
        print(e)


main()
def main():
    n = int(input())
    a = list(map(int, input().split()))

    # Only when there is no duplication in a group,
    # it always meets the condition.
    # l <= true_l < true_r < r
    ans = n
    l = 0
    now = a[0]
    for r in range(1, n):
        if now & a[r] == 0:
            now = now ^ a[r]
            continue

        now = now ^ a[r]
        for new_l in range(r-1, l-1, -1):
            if a[new_l] & a[r] != 0:
                break
        # else:
            # print('error')
            # exit()
        new_l += 1
        for i in range(l, new_l):
            now = now ^ a[i]

        ans += (r-l) * (r-l-1) // 2 - (r-new_l) * (r-new_l-1) // 2
        l = new_l

    r += 1
    ans += (r-l) * (r-l-1) // 2

    print(ans)

main()

### FIXED CODE ###

def main():
    n = int(input())
    a = list(map(int, input().split()))

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

    # Only when there is no bit duplication in a group,
    # it always meets the condition.
    # l <= true_l < true_r < r
    ans = n
    l = 0
    now = a[0]
    for r in range(1, n):
        if now & a[r] == 0:
            now = now ^ a[r]
            continue

        now = now ^ a[r]
        for new_l in range(r-1, l-1, -1):
            if a[new_l] & a[r] != 0:
                break
        # else:
            # print('Error')
            # exit()
        new_l += 1

        for i in range(l, new_l):
            now = now ^ a[i]

        ans += (r-l) * (r-l-1) // 2 - (r-new_l) * (r-new_l-1) // 2

        l = new_l

    r += 1
    ans += (r-l) * (r-l-1) // 2

    print(ans)

main()
a=input()
ans=""
while len(a)>0:
  if a[0]=="0":
    ans+="0"
  elif a[0]=="1":
    ans+="1"
  elif len(ans)>0:
    ans=ans[,-1]
print(ans)

### FIXED CODE ###

a=input()
ans=""
while len(a)>0:
  if a[0]=="0":
    ans+="0"
  elif a[0]=="1":
    ans+="1"
  elif len(ans)>0:
    ans=ans[:-1]
  a=a[1:]
print(ans)
x = int(input())

N = x // 11
M = x % 11

ans = 0
if M <= 5:
  ans = 1
else ans = 2

print(2*N + ans)


### FIXED CODE ###

x = int(input())

N = x // 11
M = x % 11

if M == 0:
  ans = 0
elif M <= 6:
  ans = 1
else:
  ans = 2

print(2*N + ans)
s=input()
if s[0]=='A':
  if s[2:-2].count('C')==1:
    if (s[1]+s[2:-2].replace('C', '')+s[-1]).islower() :
  		print('AC')
    else:
    	print('WA')
  else:
  	print('WA')
else:
  print('WA')

### FIXED CODE ###

r=int(input())
if r<1200:
  print('ABC')
elif 1200<=r and r<2800:
  print('ARC')
else:
  print('AGC')
list_a_b = input().split()
list_a_b = [int(ll) for ll in list_a_b]
dd = list_a_b[0]*list_a_b[1]
if dd %2 ==0:
  return 'Even'
else:
  return 'Odd'

### FIXED CODE ###

list_a_b = input().split()
list_a_b = [int(ll) for ll in list_a_b]
dd = list_a_b[0]*list_a_b[1]
if dd %2 ==0:
  print('Even')
else:
  print('Odd')
import sys
def input(): return sys.stdin.readline().strip()
import numpy as np


def main():
    x = input()
    if ord(x) <= 90: print("A")
    else: print("a")

if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys
def input(): return sys.stdin.readline().strip()


def main():
    x = input()
    if ord(x) <= 90: print("A")
    else: print("a")

if __name__ == "__main__":
    main()
import sys

def solve():
    input = sys.stdin.readline
    C = [int(i) for i in input().spit()]
    C.sort()
    if C[0] + C[1] == C[2]: print("Yes")
    else: print("No")

    return 0

if __name__ == "__main__":
    solve()

### FIXED CODE ###

C = [int(_) for _ in input().split()]
C.sort()
print("Yes" if C[0] + C[1] == C[2] else "No")
a=input();b=input();r=[];l=len(lb)
for i in range(l):
    r.append(a[i]); r.append(b[i])
if l != len(b):
    r.append(a[-1])
print(''.join(r))



### FIXED CODE ###

ns=list(map(int, input().split()))
ns.sort()
if ns[0] + ns[2] == ns[1]*2:
    print("YES")
else:
    print("NO")
import re

s = input()
li = s.splite("/")
month = int(li[1])

if month > 4:
  print('TBD')
else:
  print("Heisei")

### FIXED CODE ###

import re

s = input()
li = s.split("/")
month = int(li[1])

if month > 4:
  print('TBD')
else:
  print("Heisei")
s1=input()
s2=input()
n=len(s1)
m=len(s2)
import numpy as np
dp=[["" for i in range(m+1)]for i in range(n+1)]
for i in range(1,n+1):
    for j in range(1,m+1):
        if s1[i-1]==s2[j-1]:
            dp[i][j]=dp[i-1][j-1]+s1[i-1]
        else:
            a=dp[i-1][j]
            b=dp[i][j-1]
            if len(a)>len(b):
                dp[i][j]=a
            else:
                dp[i][j]=b
# print(np.array(dp))
print(dp[-1][-1])

### FIXED CODE ###

s1=input()
s2=input()
n=len(s1)
m=len(s2)
# import numpy as np
dp=[[0 for i in range(m+1)]for i in range(n+1)]
for i in range(1,n+1):
    for j in range(1,m+1):
        if s1[i-1]==s2[j-1]:
            dp[i][j]=dp[i-1][j-1]+1
        else:
            dp[i][j]=max(dp[i-1][j],dp[i][j-1])
# print(np.array(dp))
ans=""
# print(dp[-1][-1])
i=n
j=m
while i>0 and j>0:
    if dp[i][j]==dp[i-1][j]:
        i-=1
    elif dp[i][j]==dp[i][j-1]:
        j-=1
    else:
        ans=s1[i-1]+ans
        i-=1
        j-=1
print(ans)