Harryxun/stf_run huggingface dataset:
a, b = map(str, input().split())

if a==H:
  print(b)
elif a==D:
  if b==H:
    print(D)
  elif b==D:
    print(H)

### FIXED CODE ###

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

print('H' if a == b else 'D')
s,t=map(input().split())
if s>=t:
  print(t+s)
else:
  print(s+t)

### FIXED CODE ###

s,t=map(str,input().split())
print(t+s)
from itertools import groupby

s = input()
k = int(input())
a = [sum(1 for _ in g) for _, g in groupby(s)]
if s[0] == s[-1]:
    a[0] += a.pop()
print(sum(x // 2 for x in a) * k)


### FIXED CODE ###

from itertools import groupby

s = input()
k = int(input())
a = [sum(1 for _ in g) for _, g in groupby(s)]
if len(a) == 1:
    print(len(s) * k // 2)
else:
    x, y = a[0], a[-1]
    b = (x + y) // 2 if s[0] == s[-1] else x // 2 + y // 2
    print(x // 2 + y // 2 + sum(x // 2 for x in a[1:-1]) * k + b * (k - 1))
n025, n05, n1, n2 = map(int, raw_input().split())
n = input()
ans = [0 for i in range(4)]


if n >= 2:
    arr = []
    arr.append(n025 * 8)
    arr.append(n05 * 4)
    arr.append(n1 * 2)
    arr.append(n2)
    for i in range(n / 2):
        m = arr.index(min(arr))
        if m == 0:
            ans[m] += 8
        elif m == 1:
            ans[m] += 4
        elif m == 2:
            ans[m] += 2
        else:
            ans[m] += 1

n = (n % 2)

for i in range(n):
    arr = []
    arr.append(n025 * 4)
    arr.append(n05 * 2)
    arr.append(n1)
    for i in range(n):
        m = arr.index(min(arr))
        if m == 0:
            ans[m] += 4
        elif m == 1:
            ans[m] += 2
        else:
            ans[m] += 1
        
tmp = 0
tmp += ans[0] * n025
tmp += ans[1] * n05
tmp += ans[2] * n1
tmp += ans[3] * n2

print tmp

### FIXED CODE ###

n025, n05, n1, n2 = map(int, raw_input().split())
n = input()
ans = 0

if n >= 2:
    arr = []
    arr.append(n025 * 8)
    arr.append(n05 * 4)
    arr.append(n1 * 2)
    arr.append(n2)
    ans += min(arr) * (n / 2)

arr = []
arr.append(n025 * 4)
arr.append(n05 * 2)
arr.append(n1)
ans += min(arr) * (n % 2)

print ans
import numpy as np

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

Asum = sum(A)

Asort = sorted(A)
Fsort = sorted(F,reverse=True)

def test(x):
    res = max(0,Asort-x//Fsort).sum()
    return res <= K

left = -1
right = 10**13

while left+1 < right:
    mid = (left+right)//2
    if test(mid):
        right = mid
    else:
        left = mid

ans = right

print(ans)



### FIXED CODE ###

import numpy as np

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

Asum = sum(A)

Asort = np.array(sorted(A))
Fsort = np.array(sorted(F,reverse=True))

def test(x):
    res = np.maximum(0,Asort-x//Fsort).sum()
    return res <= K

left = -1
right = 10**13

while left+1 < right:
    mid = (left+right)//2
    if test(mid):
        right = mid
    else:
        left = mid

ans = right

print(ans)
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from sys import stdin
from collections import deque


def main():
  # input
  N = int(input())
  An = list(map(int, stdin.readline().rstrip().split()))

  # sort An -> Bn
  An = sorted(An)
  Bn_p,Bn_n = [deque(), deque()]
  for a in An:
    if a >= 0:
      Bn_p.append(a)
    else:
      Bn_n.append(a)

  p,n = [len(Bn_p),len(Bn_n)]      
  xy = []
  while n+p > 2:
    if p==0:
      x = Bn_n.popleft()
      y = Bn_n.popleft()
      Bn_p.append(x-y)      
      xy.append([x,y])
    elif n==0:
      x = Bn_p.popleft()
      y = Bn_p.popleft()
      Bn_n.append(x-y)      
      xy.append([x,y])
    elif p < n:
      x = Bn_p.pop()
      y = Bn_n.pop()
      Bn_p.append(x-y)
      xy.append([x,y])
    else:
      x = Bn_p.pop()
      y = Bn_n.pop()
      Bn_n.append(y-x)
      xy.append([y,x])
    p,n = [len(Bn_p),len(Bn_n)]      

  last = list(Bn_p+Bn_n)
  xy.append([max(last),min(last)])
  ans = max(last)-min(last)


  ## output
  print(ans)
  for x,y in xy:
    print(x,y)

if __name__ == "__main__":
  main()

### FIXED CODE ###

#!/usr/bin/python3
# -*- coding: utf-8 -*-
from sys import stdin
from collections import deque


def main():
  # input
  N = int(input())
  An = list(map(int, stdin.readline().rstrip().split()))
  An = sorted(An)
  Bn_p,Bn_n = [deque(),deque()]
  for a in An:
    if a >= 0:
      Bn_p.append(a)
    else:
      Bn_n.append(a)
  Bn_n = deque(sorted(Bn_n,reverse=True))

  xy = deque()
  ans = 0
  if len(Bn_p)==0:
    ## 負数のみ
    ans = Bn_n[0]
    for i in range(1,len(Bn_n)):
      x = ans
      y = Bn_n[i]
      xy.append([x,y])
      ans = x-y
  elif len(Bn_n)==0:
    ## 正数のみ
    ans = Bn_p[0]
    for i in range(1,len(Bn_p)-1):
      x = min([Bn_p[i],ans])
      y = max([Bn_p[i],ans])
      xy.append([x,y])
      ans = x-y
    xy.append([Bn_p[-1],ans])
    ans = Bn_p[-1]-ans
  else:
    ## 正負混在
    ans_n = Bn_p.popleft()
    ans_p = Bn_n.popleft()
    ### 正数はminを作り続ける
    for i in range(len(Bn_p)):
      x = ans_p
      y = Bn_p[i]
      xy.append([x,y])
      ans_p = x-y

    Bn_n.append(ans_p)
    ### 負数はmaxを作り続ける
    for i in range(len(Bn_n)):
      x = ans_n
      y = Bn_n[i]
      xy.append([x,y])
      ans_n = x-y
    ans = ans_n

  print(ans)
  for x,y in xy:
    print(x,y)

if __name__ == "__main__":
  main()
def main():
  import sys
  input = sys.stdin.readline
  n = int(input())
  a = list(map(int,input()))
  import copy
  for _ in range(n-1):
    b=[0]*(len(a)-1)
    for i in range(len(a)-1):
      b[i]=abs(a[i]-a[i+1])
      #print(b)
    a = copy.deepcopy(b)
    #print(a)

  print(b[0])
if __name__ == '__main__':
    main()

### FIXED CODE ###

h,w = [int(i) for i in input().split()]
s = []
for i in range(h):
  array = list(input())
  s.append(array)
d = [[float("inf")] * (w) for i in range(h)]
d[0][0]=0
if s[0][0]=='#':
  d[0][0]=1
for i in range(1,w):
  if s[0][i]!=s[0][i-1] and s[0][i]!=s[0][0]:
    d[0][i]=d[0][i-1]+1
  else:
    d[0][i]=d[0][i-1]
for i in range(1,h):
  for j in range(w):
    k=0
    u=0
    if j != 0 :
      if s[i][j]=="#" and s[i][j]!=s[i-1][j]:
        k=1
      if s[i][j]=="#" and s[i][j]!=s[i][j-1]:
        u=1
      d[i][j] = min(d[i-1][j]+k,d[i][j-1]+u)
    elif j == 0 :
      if s[i][0]=="#" and s[i][0]!=s[i-1][0]:
        k=1
      d[i][0] = d[i-1][0]+k

print(d[h-1][w-1])
import sys

def get_maximum_profit:
    element_number = int(input())
    v0 = int(input())
    v1 = int(input())

    min_v = v0
    max_profit = v1-v0

    for i in map(int, sys.stdin.readlines()):
        min_v = min(min_v, i)
        max_profit = max(max_profit, i-min_v)

if __name__ == '__main__':
    get_maximum_profit()

### FIXED CODE ###

import sys

def get_maximum_profit():
    element_number = int(input())
    v0 = int(input())
    v1 = int(input())

    min_v = min(v0, v1)
    max_profit = v1-v0

    for v in map(int, sys.stdin.readlines()):
        max_profit = max(max_profit, v-min_v)
        min_v = min(min_v, v)

    print(max_profit)

if __name__ == '__main__':
    get_maximum_profit()
n=int(imput())
print(n*(n+1)//2)

### FIXED CODE ###

n=int(input())
print(n*(n+1)//2)
import math


def lcm(x, y):
    return (x * y) // math.gcd(x, y)


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


gcdNM = math.gcd(N, M)
lcmNM = lcm(N, M)

isGood = True
for i in range(gcdNM):
    if S[i * N // (gcdNM)] != T[i * M // (gcdNM)]:
        isGood = False
        break

if isGood and T[0] == S[0]:
    print(lcmNM)
else:
    print(-1)


### FIXED CODE ###


def lcm(x, y):
    return (x * y) // gcd(x, y)

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

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

gcdNM = gcd(N, M)
lcmNM = lcm(N, M)

isGood = True
for i in range(gcdNM):
    if S[i * N // (gcdNM)] != T[i * M // (gcdNM)]:
        isGood = False
        break

if isGood and T[0] == S[0]:
    print(lcmNM)
else:
    print(-1)
from math import gcd
N = int(input())

ans = int(input())
for _ in range(N-1):
    t = int(input())
    g = gcd(t, ans)
    ans = ans*t//g
print(ans)

### FIXED CODE ###

N = int(input())

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

lcm = 1
for i in range(N):
    t = int(input())
    lcm = t*lcm // gcd(lcm, t)

print(lcm)
from sys import stdin
n = int(stdin.readline().rstrip())
s = "."+stdin.readline().rstrip()
kuro = s.count("#")
shiro = n-kuro
mi = shiro
k = 0
sh = shiro
for i in range(n):
    if s[i] == "#":
        k += 1
    else:
        sh -= 1
    mi = min(mi,k+s)
print(mi)

### FIXED CODE ###

from sys import stdin
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
kuro = s.count("#")
shiro = n-kuro
mi = shiro
k = 0
sh = shiro
for i in range(n):
    if s[i] == "#":
        k += 1
    else:
        sh -= 1
    mi = min(mi,k+sh)
print(mi)
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

for i in range(1, n):
    print(a[:i], b[i-1:])
    candy = []
    candy.append(sum(a[:i]) + sum(b[i-1:]))

print(max(candy))

### FIXED CODE ###

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

ans = a[0] + sum(b)
c = ans

for i in range(n-1) :
    c = c - b[i] + a[i+1]
    ans = max(ans, c)

print(ans)
n,a,b,c,d=map(int,input().split())
s=input()
if (c<d):
	if not '##' in s[a:d]: print('Yes')
	else: print('No')
elif (d<c):
	if (not '##' in s[a:c])&(s[d+1]!='#'):print('Yes')
	else: print('No')

### FIXED CODE ###

n,a,b,c,d=map(int,input().split())
s=input()
if (c<d):
	if not '##' in s[a-1:d-1]: print('Yes')
	else: print('No')
elif (d<c):
	if (not '##' in s[a-1:c-1])&('...' in s[b-2:d+1]): print('Yes')
	else: print('No')
h, n = map(int , input().split())
a = list(map(int, input().split()))
sum = 0
for i in range(n):
    sum += a[i]
print(sum)
if (h <= sum):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

h, a = list(map(int , input().split()))
count = 0
while h > 0:
    h = h - a
    count += 1

print(count)
s=input()
k=int(input())
l=list(s)

for i in range(len(s)):
  f=-ord(s[i])+ord("z")+1
  if f<=k:
    l[i]="a"
    k-=f
l[-1]=chr(ord(l[-1])+k)
print("".join(l))

### FIXED CODE ###

s=input()
k=int(input())
l=list(s)

for i in range(len(s)):
  f=(-ord(s[i])+ord("z")+1)%26
  if f<=k:
    l[i]="a"
    k-=f

k=k%26
a=ord(l[-1])+k 
if a> ord("z"):a-=26
l[-1]=chr(a)
print("".join(l))
inputs = inout().split(" ")

print(math.cell(inputs[2]/(inputs[0]+inputs[1]/7))


### FIXED CODE ###

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

days = int(C/(A+(B/7)))

while 1:
    coins = A* days + B * (days//7)

    if ( coins >= C):
        break
    else:
        days += 1

print(days)
def MaxCoinCount(A,B):
  ans = 0
  if A > B:
    ans = A + (A - 1)
  elif A < B:
    ans = B + (B + 1)
  else:
    ans = A + B

MaxCoinCount(A, B)

### FIXED CODE ###

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

def MaxCoinCount(A,B):
  ans = 0
  if A > B:
    ans = A + (A - 1)
  elif A < B:
    ans = B + (B - 1)
  else:
    ans = A + B
  return ans


print(MaxCoinCount(A,B))
import numpy as np


A, B, M = map(int, input().split())
a = list(map(int, input().split()))
a = np.array(a)
b = list(map(int, input().split()))
b = np.array(b)
z = [list(map(int, input().split())) for _ in range(M)]
z = np.array(z)


xx, yy = np.meshgrid(a, b)
xx1 = xx.flatten()
yy1 = yy.flatten()

xxyy = np.c_[xx1, yy1]
mem = xxyy.sum(axis=1)
# mem = list(mem)
mem2 = []
for x, y, c in z:
    mem2.append(a[x - 1] + b[y - 1] - c)
np.append(mem, mem2)


print(min(mem))
# print(mem)


### FIXED CODE ###

A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
L = [[int(x) for x in input().split()] for _ in range(M)]

reg = min(a) + min(b)
for x, y, c in L:
    tmp = a[x-1] + b[y-1] - c
    reg = min(reg, tmp)
print(reg)
N  = list(input())
if N[0] == N[2]:
	print('Yes')
else:
	pritn('No')

### FIXED CODE ###

N  = list(input())
if N[0] == N[2]:
	print('Yes')
else:
	print('No')
# -*- coding: utf-8 -*-

import sys
sys.setrecursionlimit(10000)

def dfs(graph, color, visit, idx):
    visit[idx] = True
    if len(graph[idx]) == 0:
        return
    for i, w in graph[idx]:
        if visit[i] is True:
            continue
        if w%2 == 0:    # 同色で塗る
            color[i] = color[idx]
        else:   # 異色で塗る
            color[i] = 1 - color[idx]   # 1-cで異色になる
        dfs(graph, color, visit, i)


N = int(input())
L = N-1
graph = [[] for _ in range(N)]
color = [-1 for _ in range(N)]
visit = [False for _ in range(N)]

for i in range(L):
    u,v,w = map(int, input().split())
    u-=1
    v-=1
    graph[u].append((v,w))
    graph[v].append((u,w))

color[0] = 0    # 添え字0をcolor0と置く
dfs(graph, color, visit, 0)

for c in color:
    print(c)


### FIXED CODE ###

# -*- coding: utf-8 -*-

from collections import deque

N = int(input())
L = N-1
graph = [[] for _ in range(N)]
color = [-1 for _ in range(N)]
visit = [False for _ in range(N)]

for i in range(L):
    u,v,w = map(int, input().split())
    u-=1
    v-=1
    graph[u].append((v,w))
    graph[v].append((u,w))

que = deque([0])    # 添え字0からアクセス開始
color[0] = 0    # 添え字0をcolor0と置く
while len(que) > 0:
    idx = que.popleft()
    visit[idx] = True
    for i, w in graph[idx]:
        if visit[i] is True:
            continue
        if w%2 == 0:    # 同色で塗る
            color[i] = color[idx]
            que.append(i)
        else:   # 異色で塗る
            color[i] = 1 - color[idx]   # 1-cで異色になる
            que.append(i)

for c in color:
    print(c)
s=input()
frag="yes"
for i in range(s):
  n=s.count(s[i])
  if n >1:
    frag="no"
    break
    
print(frag)

### FIXED CODE ###

s=input()
frag="yes"
for i in range(len(s)):
  n=s.count(s[i])
  if n >1:
    frag="no"
    break
    
print(frag)
from copy import deepcopy
def main():
    n,a,b,*h=map(int,open(0).read().split())
    h=array(h)

    ok=-1
    ng=max(h)//a+10
    
    def judge(t):
        H=deepcopy(h)
        H-=b*t
        H=H[H>0]
        if sum((H-1)//(a-b)+1)<=t:
            return 1
        else:
            return 0
    
    while abs(ok-ng)>1:
        mid=(ok+ng)//2
        if judge(mid):
            ng=mid
        else:
            ok=mid
    l=ok+1
    print(l)

if __name__ == '__main__':
    main()

### FIXED CODE ###

#import numpy as np
from numpy import*
#from scipy.sparse.csgraph import shortest_path #shortest_path(csgraph=graph)
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse.csgraph import floyd_warshall
#from scipy.sparse import csr_matrix

from collections import* #defaultdict Counter deque appendleft
from fractions import gcd
from functools import* #reduce
from itertools import* #permutations("AB",repeat=2) combinations("AB",2) product("AB",2) groupby accumulate
from operator import mul,itemgetter
from bisect import* #bisect_left bisect_right
from heapq import* #heapify heappop heappushpop
from math import factorial,pi
from copy import deepcopy
import sys
sys.setrecursionlimit(10**8)
#input=sys.stdin.readline  #危険！基本オフにしろ！

def main():
    n,a,b,*h=map(int,open(0).read().split())
    h=array(h)

    ok=-1
    ng=max(h)+10
    
    def judge(t):
        H=deepcopy(h)
        H-=b*t
        H=H[H>0]
        if sum((H-1)//(a-b)+1)<=t:
            return 1
        else:
            return 0
    
    while abs(ok-ng)>1:
        mid=(ok+ng)//2
#        print(mid,"NY"[judge(mid)])
        if judge(mid):
            ng=mid
        else:
            ok=mid
    l=ok+1
    print(l)

if __name__ == '__main__':
    main()
a=int(input())
print(a+a*a)+(a*a*a)

### FIXED CODE ###

a = int(input())
print(a+(a*a)+(a*a*a))
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


N,M = map(int, input().split())
uf = UnionFind(N)
for _ in range(M):
    a,b=map(int, input().split())
    uf.union(a,b)
cnt = 0
for i in range(N-1):
    if(not uf.same(i,i+1)):
        cnt += 1
        uf.union(i,i+1)
print(cnt)

### FIXED CODE ###

class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


N,M = map(int, input().split())
uf = UnionFind(N)
for _ in range(M):
    a,b=map(int, input().split())
    uf.union(a-1,b-1)
cnt = 0
for i in range(N-1):
    if(not uf.same(i,i+1)):
        cnt += 1
        uf.union(i+1,i)
print(cnt)
a = input()
	if a == 'AAA':
    	print('NO')
    elif a == 'BBB':
    	print('NO')
    else:
    	print('YES')

### FIXED CODE ###

bus = input()
if bus == 'AAA' or bus == 'BBB':
	print('No')
else:
	print('Yes')
N = int(input())
A = list(map(int, input().split()))
Q = int(input())

count = [0]*(10**5)
for i in range(len(A)):
  count[A[i]] += 1

A = list(set(A))
for i in range(Q):
  B, C = map(int, input().split())
  count[C] += count[B]
  count[B] = 0
  ans = 0
  for i in range(len(A)):
    ans += count[A[i]] * A[i]
  print(ans)
  

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))
Q = int(input())
S = sum(A)
count = [0]*(10**5+1)
for i in range(len(A)):
  count[A[i]] += 1

A = list(set(A))
for i in range(Q):
  B, C = map(int, input().split())
  S = S - B*count[B] + C*count[B]
  count[C] += count[B]
  count[B] = 0
  print(S)
L = ()
L.append(set(map(int, input().split())))
L.append(set(map(int, input().split())))
L.append(set(map(int, input().split())))
L.append((L[0][0], L[1][0], L[2][0]))
L.append((L[0][1], L[1][1], L[2][1]))
L.append((L[0][2], L[1][2], L[2][2]))
L.append((L[0][0], L[1][1], L[2][2]))
L.append((L[0][2], L[1][1], L[2][0]))
N = int(input())
B = (int(input()) for i in range(N))
if any(B >= l for l in L):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

a, b, c = map(int, input().split())
d, e, f = map(int, input().split())
g, h, i = map(int, input().split())
L = []
L.append({a, b, c})
L.append({d, e, f})
L.append({g, h, i})
L.append({a, d, g})
L.append({b, e, h})
L.append({c, f, i})
L.append({a, e, i})
L.append({c, e, g})
N = int(input())
B = {int(input()) for i in range(N)}
if any(l <= B for l in L):
  print("Yes")
else:
  print("No")
N = int(input())
A = list(map(int,input().split()))

M = 10**6

import math

setwise = A[0]
for i in range(1,N):
    setwise = math.gcd(setwise,A[i])
    
PrimeFactorss = [[] for _ in range(M+1)]
for i in range(2, M+1):
    if len(PrimeFactorss[i]) == 0:
        for x in range(i, M+1, i):
            PrimeFactorss[x].append(i)
num_list = [0]*(M+1)

for i in range(N):
    num_list[A[i]] += 1

pairwise = [0]*(M+1)

for i in PrimeFactorss[x]:
    for j in range(i,M+1,i)
    if num_list[i]==1:
        pairwise[i] += 1
        
ans = 0    
for i in pairwise:
    if i>1:
      ans += 1
      break
    
if ans == 0:
    print("pairwise coprime")
elif setwise == 1:
    print("setwise coprime")
else:
    print("not coprime")



### FIXED CODE ###

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

M = 10**6

import math

setwise = A[0]
for i in range(1,N):
    setwise = math.gcd(setwise,A[i])
    
PrimeFactorss = [[] for _ in range(M+1)]
for i in range(2, M+1):
    if len(PrimeFactorss[i]) == 0:
        for x in range(i, M+1, i):
            PrimeFactorss[x].append(i)
num_list = [0]*(M+1)

for i in range(N):
    num_list[A[i]] += 1

pairwise = [0]*(M+1)

n=M
primes = set(range(2, n+1))
for i in range(2, int(n**0.5+1)):
    primes.difference_update(range(i*2, n+1, i))
primes=list(primes)

for i in primes:
    for j in range(i,M+1,i):
        if num_list[j]==1:
            pairwise[i] += 1
        
ans = 0    
for i in pairwise:
    if i>1:
        ans += 1
        break
    
if setwise == 1 and ans == 0:
    print("pairwise coprime")
elif setwise == 1:
    print("setwise coprime")
else:
    print("not coprime")
S = list(map(int, input().split()))

K = S[0]
X = S[1]


A = abs(X-K)+1
B = X+K

if i in range(A, B, 1):
  print(i, end="")


### FIXED CODE ###

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

K = S[0]
X = S[1]


A = X-K+1
B = X+K

for i in range(A, B, 1):
  print(i, end="")
  print(" ", end="")
x=int(input())

for i in range(-118,120):
  for j in range(-119,119):
    if i**5-j**5==x:
      print(i,j)
      exit(1)


### FIXED CODE ###

x=int(input())
# an = n^5 - (n - 1)^5
# a -> 120~-119 -> -118~119
# b -> 119~-120 -> -119~118
for i in range(-118,120):
  for j in range(-119,119):
    if i**5-j**5==x:
      print(i,j)
      exit()
#input
h, w = list(map(int, input().split()))

c = [0 for i in range(10)]
for i in range(10):
    c[i] = list(map(int, input().split()))

wall = [0 for i in range(w)]

for i in range(h):
    wall[i] = list(map(int, input().split()))

#solve
#0へのコスト
costone = [((10**4) + 1) for i in range(11)]
#-1, 1はコストがかからないため０で初期化
costone[1] = 0
costone[10] = 0
#ワーシャルフロイド法を使う
#iは出発、jは経由,
for i in range(10):
    for j in range(10):
        for k in range(10):
            c[i][k] = min(c[i][k], c[i][j] + c[j][k])
#costoneを更新
for i in range(10):
    costone[i] = min(costone[i], c[i][1])
sum = 0
for i in range(h):
    for j in range(w):
        sum += costone[wall[i][j]]
print(sum)


### FIXED CODE ###

from scipy.sparse.csgraph import floyd_warshall

#input
h, w = list(map(int, input().split()))

c = [0 for i in range(10)]
for i in range(10):
    c[i] = list(map(int, input().split()))

wall = []

for i in range(h):
    wall.append(list(map(int, input().split())))

#solve
#1へのコスト
costone = [(10**3) + 1 for i in range(11)]
#-1, 1はコストがかからないため０で初期化
costone[1] = 0
#-1の処理
costone[10] = 0
#ワーシャルフロイド法を使う
#iは出発、jは経由,
c = floyd_warshall(c)
##for i in range(10):
##    for j in range(10):
##        for k in range(10):
##            c[i][k] = min(c[i][k], c[i][j] + c[j][k])
#costoneを更新
for i in range(10):
    costone[i] = min(costone[i], c[i][1])
sum = 0


for i in range(h):
    for j in range(w):
        sum += costone[wall[i][j]]
print(int(sum))
import numpy as np
N,K = map(int,input().split(' '))
h = []
for i in [0]*N:
	h.append(int(input()))


def sort(l):
	m = sum(l)/len(l)
	a = [x for x in l if x < m]
	b = [x for x in l if m <= x]
	if a == []:
		return b
	if b == []:
		return a
	return sort(a)+sort(b)

h = np.array(h)
sh = np.sort(h)
#sh = sort(h)
ans = max(h)
for i in range(0,N-K+1):
	s = (sh[i+K-1] - sh[i])
	if s < ans:
		ans = s
print(ans)



### FIXED CODE ###

D = int(input())
if D is 25:
	print('Christmas')
if D is 24:
	print('Christmas Eve')
if D is 23:
	print('Christmas Eve Eve')
if D is 22:
	print('Christmas Eve Eve Eve')