Harryxun/stf_run huggingface dataset:
a=list(input())
if a[0]==a[1]:
  print("Bad")
  elif a[1]==a[2]:
    print("Bad")
    elif a[2]==a[3]:
      print("Bad")
      else:
        print("Good")

### FIXED CODE ###

s=input()
if s[0]==s[1] or s[1]==s[2] or s[2]==s[3]:
  print("Bad")
else:
  print("Good")
import math
#x=int(input())
a,b=map(int,input().split())
c=math.gcd(a,b)
print((a*b)/c)

### FIXED CODE ###

def gcd(a,b):
    if a==0:
        return b
    else:
        return gcd(b%a,a)
#x=int(input())
a,b=map(int,input().split())
c=gcd(a,b)
print((a*b)//c)
s = map(str,input().split())
if int(s[5]) == 1:
  print("TBD")
elif int(s[6]) <= 4:
  print("Heisei")
else:
  print("TBD")

### FIXED CODE ###

s = input()
if int(s[5]) == 1:
  print("TBD")
elif int(s[6]) <= 4:
  print("Heisei")
else:
  print("TBD")
H, W = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(H)]

l = []
for y in range(H):
    l += [(x, y) for x in list(range(W))[::-1 if y%2 else 1]]

p = []
for i, (x, y) in enumerate(l):
    if A[y][x] % 2 == 0:
        continue
    nx, ny = l[i+1]
    p.append((x+1, y+1, nx+1, ny+1))
    A[y][x] -= 1
    A[ny][nx] += 1

print(len(p))
[print(*p_i) for p_i in p]


### FIXED CODE ###

H, W = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(H)]

l = []
for y in range(H):
    l += [(x, y) for x in list(range(W))[::-1 if y%2 else 1]]

p = []
for i, (x, y) in enumerate(l[:-1]):
    if A[y][x] % 2 == 0:
        continue
    nx, ny = l[i+1]
    p.append((x+1, y+1, nx+1, ny+1))
    A[y][x] -= 1
    A[ny][nx] += 1

print(len(p))
[print(*p_i[::-1]) for p_i in p]
import copy
import math
from functools import reduce


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


n = int(input())
a = list(map(int, input().split()))
nl = set(range(n))
gcd_list = []
for i in nl:
    tmp = copy.deepcopy(a)
    tmp.pop(i)
    gcd_list.append(gcd(*tmp))
ans = max(gcd_list)
print(ans)

### FIXED CODE ###

import fractions


n = int(input())
a = list(map(int, input().split()))
nl = set(range(n))
l = [0]
r = [0]
m = []
for i in nl:
    l.append(fractions.gcd(l[i], a[i]))
    r.append(fractions.gcd(r[i], a[-i-1]))
r.reverse()
for i in nl:
    m.append(fractions.gcd(l[i], r[i+1]))
ans = max(m)
print(ans)
import numpy as np
h, w = map(int, input().split())
S = []
for i in range(h):
    S.append(input())
 
sw = []
 
for i in range(h):
    c = []
    for j in range(w):
        if S[i][j] == '#':
            c.append(j)
    c.append(w)
    k = []
    p = c[0]
    k += [p] * p
    k += [0]
    for j in range(1, len(c)):
        p = c[j] - c[j-1] - 1
        k += [p] * p
        k += [0]
    sw.append(k[0:-1])
 
sh =[]
 
for i in range(w):
    c = []
    for j in range(h):
        if S[j][i] == '#':
            c.append(j)
    c.append(h)
    k = []
    p = c[0]
    k += [p] * p
    k += [0]
    for j in range(1, len(c)):
        p = c[j] - c[j-1] - 1
        k += [p] * p
        k += [0]
    sh.append(k[0:-1])
 
sw = np.array(sw)
sh = np.array(sh)
sh = sh.T
 
x = sw + sh
 
print(np.amax(x) - 1)

### FIXED CODE ###

H,W=map(int,input().split())
S=[]
for i in range(H):
    s=input()
    S.append(s)

Gh=[[0]*W for i in range(H)]
for i in range(H):
    tmp=0
    s=0
    j=0
    while(j!=W):
        if S[i][j]=="#":
            Gh[i][j]==0
            for k in range(s,j):
                Gh[i][k]=tmp
            s=j+1
            j+=1
            tmp=0
        else:
            tmp+=1
            j+=1
    if s!=j:
        for k in range(s,j):
            Gh[i][k]=tmp
Gv=[[0]*W for i in range(H)]
for j in range(W):
    tmp=0
    s=0
    i=0
    while(i!=H):
        if S[i][j]=="#":
            Gv[i][j]==0
            for k in range(s,i):
                Gv[k][j]=tmp
            s=i+1
            i+=1
            tmp=0
        else:
            tmp+=1
            i+=1
    if s!=i:
        for k in range(s,i):
            Gv[k][j]=tmp
ans=0
for i in range(H):
    for j in range(W):
        ans=max(ans,Gh[i][j]+Gv[i][j]-1)
print(ans)
print(max([len(s) for s in "".join(["1" if s in ["A","C","G","T"] else " " for s in input()]).split()]))

### FIXED CODE ###

a="".join(["1" if s in ["A","C","G","T"] else "0" for s in input()])
ans=[len(s) for s in a.split("0")]
print(max(ans))
group = {}
for _ in range(int(input())):
  group.add(input())
print(len(group))

### FIXED CODE ###

group = set()
for _ in range(int(input())):
  group.add(input())
print(len(group))
n, k = map(int, input().split())
a_sort = sorted(list(map(int, input().split())))

MOD = 10**9 + 7

def SUM(a):
    count_max = 0
    count_min = 0
    comb = 1
    for i in range(len(a)):
        if i == k-1:
            count_max += a[i]
            count_min += a[-i-1]
        elif i > k-1:
            comb = comb * i // (i-k+1)
            count_max = (count_max + (comb * a[i])) % MOD
            count_min = (count_min + (comb * a[-i-1])) % MOD
    return (count_max - count_min + MOD) % MOD

Max = SUM(a_sort)
Min = SUM(a_sort.reverse())

print((Max - Min + MOD) % MOD)


### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
 
class Combination():
    # コンストラクタ
    def __init__(self, N:int, P:int):
        self.N = N
        self.P = P
 
        # fact[i] = (i! mod P)
        self.fact = [1, 1]   
        # factinv[i] = ((i!)^(-1) mod P)
        self.factinv = [1, 1]
        # factinv 計算用
        self.inv = [0, 1]    
 
        for i in range(2, N+1):
            self.fact.append((self.fact[-1] * i) % P)
            self.inv.append((-self.inv[P % i] * (P // i)) % P)
            self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)
    
    # nCk (mod P)   (ただし、n<=N)
    def getComb(self, n:int, k:int):
        if (k < 0) or (n < k):
            return 0
        k = min(k, n - k)
        return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P
 
def main():
    N,K = map(int,input().split())
    A = sorted([int(i) for i in input().split()])
 
    mod = 10**9+7
 
    COMB = Combination(N,mod)
 
    cmb = [0] * (N-K+1)
    for i in range(N-K+1):
        cmb[i] = COMB.getComb(i+(K-1),K-1)
 
    sum_max = 0
    for i in range(K-1,N):
        sum_max = (sum_max + cmb[i-(K-1)] * A[i]) % mod
 
    sum_min = 0
    for i in range(N-K,-1,-1):
        sum_min = (sum_min + cmb[(N-K)-i] * A[i]) % mod
 
    answer = sum_max - sum_min
    print(answer % mod)
 
if __name__ == "__main__":
    main()
n=int(input())
s=input()
maxx=-
def got(a,al):
	for i in a:
    	if i==al:
      		return(True)
	return(False)
for i in range(n):
	a=s[:i]
  	b=s[i:]
  	cnt=0
  	alp="abcdefghijklmnopqrstuvwxyz"
  	for al in alp:
    	if got(a,al) and got(b,al):
      		cnt+=1
  	maxx=max(maxx,cnt)
print(maxx)

### FIXED CODE ###

n=int(input())
s=input()
maxx=-1
def got(a,al):
    for i in a:
        if i==al :
      	    return(True)
    return(False)
for i in range(n):
    a=s[:i]
    b=s[i:]
    cnt=0
    alp="abcdefghijklmnopqrstuvwxyz"
    for al in alp:
        if got(a,al) and got(b,al):
      	    cnt+=1
    maxx=max(maxx,cnt)
print(maxx)
n = int(input())
a = [int(i) for i in input.split()]
ans = 0
for i in range(1, n):
  if a[i] < a[i - 1]:
    ans += a[i - 1] - a[i]
print(ans)

### FIXED CODE ###

n = int(input())
a = [int(i) for i in input().split()]
ans = 0
for i in range(1, n):
  if a[i] < a[i - 1]:
    ans += a[i - 1] - a[i]
    a[i] += (a[i - 1] - a[i])
print(ans)
def lcm_core(a,b):
    g = gcd_core(a,b)
    return (a*b)//g

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

def lcm(arr):
    m = 10**9+7
    mcnt = 0
    l = lcm_core(arr[0],arr[1])
    for i in range(2,len(arr)):
        l = lcm_core(l,arr[i])
        mcnt += l//m
        l %= m
    return l,mcnt

n = int(input())
arr = list(map(int,input().split()))
l,mcnt = lcm(arr)

# print(l)
m = 10**9+7

ans = 0
for i in range(n):
    temp = l + (m%arr[i])*mcnt
    # print(temp)
    ans += (temp//arr[i]) + (m//arr[i])*mcnt
    ans %= m

print(ans)



### FIXED CODE ###

import fractions
from functools import reduce

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

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

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

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

mod = 10 ** 9 + 7

l = lcm_list(A)

ans = 0

for i in range(N):
  ans += l // A[i]

ans = ans % mod

print(ans)
s=input.split(",")
print(*s)

### FIXED CODE ###

s=input().split(",")
print(*s)
import sys
sys.setrecursionlimit(4100000)
import math
a,b,c,d = [int(i) for i in input().split()]
lcm = (c * d) // math.gcd(c, d)
# a = 9-9//2-9//3+9//lcm
# b = 4-4//2-4//3+4//lcm
a -= 1
e = b-b//c-b//d+b//lcm
f = a-a//c-a//d+a//lcm
print(e-f)

### FIXED CODE ###

import sys
sys.setrecursionlimit(4100000)
import fractions
a,b,c,d = [int(i) for i in input().split()]
lcm = (c * d) // fractions.gcd(c, d)
# a = 9-9//2-9//3+9//lcm
# b = 4-4//2-4//3+4//lcm
a -= 1
e = b-b//c-b//d+b//lcm
f = a-a//c-a//d+a//lcm
print(e-f)
n, m = map(int, input().split())
x = list(map(int, input().split()))
x.reverse()
mincost = 2 * n * m + 5 * sum(x)
for k in range(1,n):
    cost = m * (n + k)
    for i in range(n):
        cost += max(5, 3 + i//k * 2) * x[i]
    mincost = min(mincost, min)
print(mincost)

### FIXED CODE ###

n, m = map(int, input().split())
x = list(map(int, input().split()))
x.reverse()
cum = [0] * (n+1)
for i in range(n):
    cum[i+1] = cum[i] + x[i]
mincost = 2 * n * m + 5 * cum[n]
for k in range(1,n):
    cost = m * (n + k)
    for i in range(n//k):
        cost += (cum[(i+1)*k] - cum[i*k]) * max(5, 3 + i*2)
    cost += (cum[n] - cum[n//k * k]) * max(5, 3 + n//k*2)
    mincost = min(mincost, cost)
print(mincost)
from math import floor

def f(x,y,n):
  if x >= y:
    return x
  else:
    n += 1
    x += floor(x*0.01)
    return f(x,y,n)

x = int(input())
print(f(100,x,n))

### FIXED CODE ###

from math import floor

y = int(input())
x = 100
n = 0
while x < y:
    x += floor(x * 0.01)
    n += 1

print(n)
def main42():
    data = input()
    nagasa = len(data)
    result = 10000
    for i in range(0,nagasa-2,1):
        kari = data[i:i+3]
        num = int(kari)
        if result > abs(num - 753)

if __name__ == "__main__":
    main42()

### FIXED CODE ###

def main42():
    data = input()
    nagasa = len(data)
    result = 10000
    for i in range(0,nagasa-2,1):
        kari = data[i:i+3]
        num = int(kari)
        if result > abs(num - 753):
            result = abs(num - 753)
    print(result)

if __name__ == "__main__":
    main42()
def nyu():
    num1,num2,num3 = input().split()
    #num2 = list(map(int,input().split()))
    num1 = int(num1)
    num2 = int(num2)
    num3 = int(num3)
    return num1,num2,num3

def check(N,A,B):
    sum_cnt=0
    

    for n in range(N+1):
        sum:int = 0
        tmp_n = n
        sum += int(tmp_n/10000)
        tmp_n = tmp_n % 10000
        sum += int(tmp_n/10000)
        tmp_n = tmp_n % 1000
        sum += int(tmp_n/100)
        tmp_n = tmp_n % 100
        sum += int(tmp_n/10)
        tmp_n = tmp_n % 10
        sum += tmp_n
    
        if A<=sum and sum<=B:
        #    print("n=",n,"sum=", sum)
            sum_cnt +=n
    print(sum_cnt)

N,A,B=nyu()
check(N,A,B)



### FIXED CODE ###

def nyu():
    num1,num2,num3 = input().split()
    #num2 = list(map(int,input().split()))
    num1 = int(num1)
    num2 = int(num2)
    num3 = int(num3)
    return num1,num2,num3

def check(N,A,B):
    sum_cnt=0
    sum = 0
    for n in range(N+1):
        sum = 0
    #     tmp_n = n
    #     sum += int(tmp_n/10000)
    #     tmp_n = tmp_n % 10000
    #     sum += int(tmp_n/10000)
    #     tmp_n = tmp_n % 1000
    #     sum += int(tmp_n/100)
    #     tmp_n = tmp_n % 100
    #     sum += int(tmp_n/10)
    #     tmp_n = tmp_n % 10
    #     sum += tmp_n
        n_str = str(n)
        l_n_str = list(n_str)
    #   print(l_n_str)
        for ln in l_n_str:
            sum += int(ln)

        if A<=sum and sum<=B:
#           print("n=",n,"sum=", sum)
            sum_cnt +=n
    print(sum_cnt)

N,A,B=nyu()
check(N,A,B)
import math
N = int(input())
fn = {i+1:0 for i in range(N)}
rtN = int(math.sqrt(N))+1

def n(x,y,z):
    return x**2 + y**2 + z**2 + x*y + y*z + z*x

for x in range(1, rtN):
    for y in range(1, rtN):
        for z in range(1, rtN):
            n_ = n(x,y,z)
            try:
                f[n_] += 1
            except KeyError:
                pass

for k in fn.values():
    print(k)

### FIXED CODE ###

import math
N = int(input())
fn = {i+1:0 for i in range(N)}
rtN = int(math.sqrt(N))+1

def n(x,y,z):
    return x**2 + y**2 + z**2 + x*y + y*z + z*x

for x in range(1, rtN):
    for y in range(1, rtN):
        for z in range(1, rtN):
            n_ = n(x,y,z)
            try:
                fn[n_] += 1
            except KeyError:
                pass

for k in fn.values():
    print(k)
n = int(input())
b = list(map(int, input().split()))
ans = b[0]
for i in range(len(b)-1):
  ans.append(min(b[i], b[i+1]))
ans += b[-1]
print(ans)


### FIXED CODE ###

n=int(input())
print(n**3)
s = str(inpout())

for i in range(len(s)):
    if s[i] == s[i+1]:
        res1 = str(i)
        res2 = str(i+1)
        print(res1 + " " + res2)
        break
    elif s[i] == s[i+2]:
        res1 = i
        res2 = i+2
        print(res1 + " " + res2)
        break
    else:
        continue

print("-1 -1")

### FIXED CODE ###

s = str(input())


if len(s) > 2:
    for i in range(len(s)-2):
        if s[i] == s[i+1] or s[i] == s[i+2]:
            res1 = str(i+1)
            res2 = str(i+3)
            print(res1 + " " + res2)
            quit()
        else:
            continue
else:
    if s[0] == s[1]:
        print("1 2")
        quit()

print("-1 -1")
s = input()
cand = []
ans = [0] * len(s)

# RLの位置を把握
for i in range(len(s)-1):
    if s[i] == "R" and s[i+1] == "L":
        cand.append(i)
for j in range(len(cand)):
    if j == 0:
        lst_l = s[:cand[j]]
        lst_r = s[cand[j]+2:cand[j+1]]
    elif j == len(cand)-1:
        lst_l = s[cand[j-1]+2:cand[j]]
        lst_r = s[cand[j]+2:]
    else:
        lst_l = s[cand[j-1]+2:cand[j]]
        lst_r = s[cand[j]+2:cand[j+1]] 
    num_R = len([i for i in lst_l if i == "R"])
    num_L = len([i for i in lst_r if i == "L"])
    num = num_R + num_L
    j = cand[j]
    if num % 2 == 0:
        ans[j:j+2] = [num//2+1, num//2+1]
    else:
        if num_R == 0 or num_L == 0:
            if num_R == 0:
                ans[j:j+2] = [num_L-(num_L//2)+1, num_L//2+1]
            else:
                ans[j:j+2] = [num_R//2+1, num_R-(num_R//2)+1]
        else:
            ans[j:j+2] = [num_R+1, num_L+1]
print(*ans)

### FIXED CODE ###

S = input()
seq = [1]
pos = []
for i,(a,b) in enumerate(zip(S,S[1:])):
    if a+b == 'RL':
        pos.append(i)
    if a==b:
        seq[-1] += 1
    else:
        seq.append(1)

ans = [0] * len(S)
for r,l,p in zip(seq[::2],seq[1::2],pos):
    ans[p] = ans[p+1] = (r+l)//2
    if (r+l)%2:
        if r > l:
            ans[p] += 1
        else:
            ans[p+1] += 1
        if max(r,l)%2==0:
            ans[p],ans[p+1] = ans[p+1],ans[p]
print(*ans)
N, Ma, Mb= (int(i) for i in input().split())
L = []
for i in range(N):
    a, b, c = (int(i) for i in input().split())
    L.append((a-1, b-1, c))

dp= [[[float("inf")] * (10 * N + 11) for a in range(10 * N + 11) ] for i in range(N + 1)]
dp[0][0][0] = 0

for i in range(N + 1):
    a, b, c = L[i]
    for ca in range(10 * N + 1):
        for cb in range(10 * N + 1):
            dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
            dp[i+1][ca + a][cb + b] = min(dp[i+1][ca + a][cb + b], dp[i][ca][cb] + c)

reslis = []
ra, rb = (Ma, Mb)
while ra <= 10 * N and rb <= 10 * N:
    reslis.append(dp[N][ra][rb])
    ra += Ma
    rb += Mb

reslis.sort()
res = reslis[0]
if res == float("inf"):
    print(-1)
else:
    print(res)


### FIXED CODE ###

N, Ma, Mb= (int(i) for i in input().split())
L = []
for i in range(N):
    a, b, c = (int(i) for i in input().split())
    L.append((a, b, c))

dp= [[[float("inf")] * (10 * N + 11) for a in range(10 * N + 11) ] for i in range(N + 1)]
dp[0][0][0] = 0

for i in range(N):
    a, b, c = L[i]
    for ca in range(10 * N + 1):
        for cb in range(10 * N + 1):
            dp[i+1][ca][cb] = min(dp[i+1][ca][cb], dp[i][ca][cb])
            dp[i+1][ca + a][cb + b] = min(dp[i+1][ca + a][cb + b], dp[i][ca][cb] + c)

reslis = []
ra, rb = (Ma, Mb)
while ra <= 10 * N and rb <= 10 * N:
    reslis.append(dp[N][ra][rb])
    ra += Ma
    rb += Mb

reslis.sort()
res = reslis[0]
if res == float("inf"):
    print(-1)
else:
    print(res)
N, K = map(int, input().split())
A = list(map(int, input().split()))

dist = A[0]
visited = set()
_v = [1]
stop = 0
while True:
    if dist in visited:
        stop = dist
        break
    visited.add(dist)
    _v.append(dist)
    dist = A[dist-1]

made = 0
for i in range(len(_v)):
    if _v[i] == stop:
        break
    made += 1

loop = len(_v) - made
_v = _v[made:]

if K <= made:
    print(_v[K])
else:
    K -= made
    K %= loop
    print(_v[K])


### FIXED CODE ###

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

dist = A[0]
visited = {1}
_v = [1]
stop = 0
while True:
    if dist in visited:
        stop = dist
        break
    visited.add(dist)
    _v.append(dist)
    dist = A[dist-1]

made = 0
l = len(_v)
for i in range(l):
    if _v[i] == stop:
        break
    made += 1

# print(stop)
# print(loop)
# print(made)
# print(_v)

if K <= made:
    print(_v[K])
else:
    loop = l - made
    _v = _v[made:]
    K -= made
    K %= loop
    print(_v[K])
S = input()

if S == 'SAT':
  print(1)
elif S=='FRI':
  print(2)
elif S=='THU':
  print(3)
elif S=='WED':
  print(4)
elif S=='TUE':
  print(5)
elif S=='MON':
  print(6)
else S=='SUN':
  print(7)


### FIXED CODE ###

S = input()

if S == "SUN":
    print(7)
elif S == "MON":
    print(6)
elif S == "TUE":
    print(5)
elif S == "WED":
    print(4)
elif S == "THU":
    print(3)
elif S == "FRI":
    print(2)
else:
    print(1)
S = str(inpiut())
T = str(input())

S = S+S
if T in S:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

S = str(input())
T = str(input())
 
S = S+S
if T in S:
  print('Yes')
else:
  print('No')
s=str(input())

N=int(input())
cnt=0
f=''
b=''
for i in range(N):
  inp=str(input())
  if len(inp)==1:
    cnt+=1
  else:
    F,c=int(inp[2]),inp[4]
    if F==1:
      if cnt%2==0:
        f=c+f
      else:
        b+=c
    else:
      if cnt%2==0:
        b+=c
      else:
        f=c+f
if cnt%2==0:
  print(f+s+b)
else:
  ans=f+s+b
  L=len(ans)
  if L%2==1:
    f=ans[0:L//2]
    s=ans[L//2]
    b=ans[L//2+1:L]
    print(''.join(list(reversed(b))))+s+''.join(list(reversed(f)))
  else:
    f=ans[0:L//2]
    b=ans[L//2:L]
    f_=''.join(list(reversed(b)))
    b_=''.join(list(reversed(f)))
    print(f_+b_)

### FIXED CODE ###

s=str(input())

N=int(input())
cnt=0
f=''
b=''
for i in range(N):
  inp=str(input())
  if len(inp)==1:
    cnt+=1
  else:
    F,c=int(inp[2]),inp[4]
    if F==1:
      if cnt%2==0:
        f=c+f
      else:
        b+=c
    else:
      if cnt%2==0:
        b+=c
      else:
        f=c+f
if cnt%2==0:
  print(f+s+b)
else:
  ans=f+s+b
  L=len(ans)
  if L==1:
    print(ans)
  else:
    if L%2==1:
      f=ans[0:L//2]
      s=ans[L//2]
      b=ans[L//2+1:L]
      f_=''.join(list(reversed(b)))
      b_=''.join(list(reversed(f)))
      print(f_+s+b_)
    else:
      f=ans[0:L//2]
      b=ans[L//2:L]
      f_=''.join(list(reversed(b)))
      b_=''.join(list(reversed(f)))
      print(f_+b_)
n=int(input())
L={}
c=0
for i in range (n):
    s=input()
    if s in L:
        L[s]+=1
    else:
        L.update({s:1})
        c+=1
M=list(L.values())
C=list(L.keys())
b=max(M)
F=[]
for i in range(c):
    if M[i]==b:
        F+=[C[i]]
F.sort()
for i in F:
    print(i)
        
    


### FIXED CODE ###

A,B,C=map(int,input().split())
print((A==B and B!=C or A==C and C!=B or B==C and B!=A) and "Yes" or "No")
import math
a,b,c,d = map(int, input().split())
cd = math.gcd(cd)
 
def f(x,y,div):
  return int(max(x,y)/div) - int((min(x,y)-1) / div)
print(a-b+1- f(a,b,c) - f(a,b,d) + f(a,b,cd))

### FIXED CODE ###

a, b, c, d = map(int, input().split())
 
def gcd(x, y):
    if x % y == 0:
        return y
    return gcd(y, x%y)
 
cd = c // gcd(c,d) * d

a -= 1
a_ = a - a//c - a//d + a//cd
b_ = b - b//c - b//d + b//cd
 
print(b_ - a_)
N = int(input())
A = list(map(int, input()))

result = [0] * N

for a in A:
  result[a-1] += 1
  
for i in range(N):
  print(result[i])

### FIXED CODE ###

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

result = [0] * N

for a in A:
  result[a-1] += 1
  
for i in range(N):
  print(result[i])
from collections import Counter
import sympy


len_arr = int(input())
arr = list(map(int, input().split()))
counter = Counter(arr)
st = set(arr)

ans = 0
for value, count in counter.items():
    if count > 1:
        continue
    divs = set(sympy.divisors(value))
    if len(divs & st) == 1:
        ans += 1

print(ans)


### FIXED CODE ###

import numpy as np
from collections import Counter


len_arr = int(input())
arr = list(map(int, input().split(' ')))
counter = Counter(arr)
x_max = max(counter.keys())

dp = np.empty(x_max+1, dtype=np.bool_)
dp[:] = True

ans = 0

for x, count in sorted(counter.items()):
    multi = [x*y for y in range(1, x_max//x+1)]
    if count == 1 and dp[x]:
        ans += 1
    dp[multi] = False

print(ans)
while True:
    n, m = (int(s) for s in input().split())
    if not n:
        break

    sections = sorted(([int(s) for s in input().split()] for i in range(n)),
                      key=lambda x: x[1], reverse=True)

    for i, (d, p) in enumerate(sections):
        m -= d
        if m <= 0:
            print(sum(s[0] * s[1] for s in sections[i+1:]) - p * m)
            break
    else:
        print(0)

### FIXED CODE ###

while True:
    n, m = (int(s) for s in input().split())
    if not n:
        break

    sections = sorted(([int(s) for s in input().split()] for i in range(n)),
                      key=lambda x: x[1], reverse=True)

    for i, (d, p) in enumerate(sections):
        m -= d
        if m <= 0:
            print(sum(s[0] * s[1] for s in sections[i+1:]) - p * m)
            break
    else:
        print(0)
#まだ自信をもっと答えられないんだよな
#掛け算じゃなくて最小公倍数や
import math
a,b,c,d=[int(i) for i in input().split()]
c1=b//c-a//c
if a%c==0:
    c1+=1
d1=b//d-a//d
if a%d==0:
    d1+=1
cd1=b//(c*d//math.gcd(c,d))-a//(c*d//math.gcd(c,d))
if a%(c*d)==0:
    cd1+=1
print(c1)
print(d1)
print(cd1)
print(b-a+1-c1-d1+cd1)



### FIXED CODE ###

#まだ自信をもっと答えられないんだよな
#掛け算じゃなくて最小公倍数や
#デバッグの後消す
import fractions
a,b,c,d=[int(i) for i in input().split()]
c1=b//c-a//c
if a%c==0:
    c1+=1
d1=b//d-a//d
if a%d==0:
    d1+=1
cd1=b//(c*d//fractions.gcd(c,d))-a//(c*d//fractions.gcd(c,d))
if a%(c*d)==0:
    cd1+=1
#print(c1)
#print(d1)
#print(cd1)
print(b-a+1-c1-d1+cd1)
#役立つhttps://qiita.com/chun1182/items/ddf2b6cba932b2bb0d4e
import sys
n,m=map(int,input().split())
arr=[1,2]
arr=arr+[0]*(n-2)
danger=tuple(map(int,sys.stdin))
m=0
if 1 == danger[0]:
  arr[0]=0
  arr[1]=1
  m=1
for i in range(n):
  if i+1 in danger[m]:
    arr[i]=0
    m+=1
  elif i==0 or i==1:
    continue 
  else:
    arr[i]=(arr[i-1]+arr[i-2])%(10**9+7)
print(arr[n-1]%(10**9+7))


### FIXED CODE ###

import sys
n,m = map(int,input().split())
a = list(map(int,sys.stdin))
a.append(0)
prev=0
cur=1
m=0
for i in range(1,n+1):
  if a[m]==i:
    prev,cur = cur,0
    m += 1
  else:
    prev,cur = cur,(cur+prev)%1000000007
print(cur)
foo={}
bar={}
n=int(raw_input())
for x in map(int,raw_input().split()):
    if x not in foo:
        foo[x]=0
    foo[x]+=1
n=int(raw_input())
for x in map(int,raw_input().split()):
    if x not in bar:
        bar[x]=0
    bar[x]+=1
for i in foo:
    if i not in bar:
        continue
    if foo[i]<bar[i]:
        print "NO"
        exit(0)
print "YES"


### FIXED CODE ###

y=list(raw_input())
y.reverse()
foo=''
for i in range(len(y)):
    foo+=y[i]
    if foo=='LAVITSEF':
        j=i
        break
x=y[j+1:]
x.reverse()
print ''.join(x)