Harryxun/stf_run huggingface dataset:
N=input()
if N[0]==N[1] and N[1]==N[2]:
	print("Yes")
elif N[2]==N[3] and N[3]==N[4]:
	print("Yes")
else:
	print("No")

### FIXED CODE ###

N=input()
if N[0]==N[1] and N[1]==N[2]:
	print("Yes")
elif N[1]==N[2] and N[2]==N[3]:
	print("Yes")
else:
	print("No")
a,b,n=map(int,input().split())
x=0
if n>b:
    x=b
else:
  x=n
ans1=int(a*x/b)-a*int(x/b)
print(ans2)

### FIXED CODE ###

a,b,n=map(int,input().split())
x=0
if n>b-1:
    x=b-1
else:
  x=n
ans=int(a*x/b)-a*int(x/b)
print(ans)
n = input()
for i in range(0, n-1)
   R[i] = input()
minv = R[0]
maxv = R[1] - R[0]
for j in range(1, n-1)
  maxv = max(maxv, R[j] - minv) 
  minv = min(minv, R[j])
print maxv - minv

### FIXED CODE ###

n = input()
R = []
for i in range(0, n):
   R.append(int(raw_input()))

maxv = R[1] - R[0]
minv = R[0]

for v in range(1, n):
   if minv > R[v]:
      minv = R[v]
   elif maxv < R[v] - minv:
      maxv = R[v] - minv
print maxv
satoooh
, M = map(int, input().split())
A, B = [0] * N, [0] * N
for i in range(N):
	A[i], B[i] = map(int, input().split())

#  値段Aの昇順でソート
C = sorted(zip(A, B))
A, B = zip(*C)

ans, cnt, i = 0, 0, 0
while cnt < M:
	tmp = min(B[i], M - cnt)
	cnt += tmp
	ans += A[i] * tmp
	i += 1
print(ans)


### FIXED CODE ###

N, M = list(map(int, input().split()))
data = [list(map(int, input().split())) for _ in range(N)]
data.sort()

honsu=0
cost=0
for i in range(N):
  honsu+=data[i][1]
  cost+=data[i][0]*data[i][1]
 
  if honsu>M:
    cost=cost-((honsu-M)*data[i][0])
    print(cost)
    exit()
print(cost)
Sa = list(input())
Sb = list(input())
Sc = list(input())
for _ in range(10**8):
    if _ == 0:
        s = Sa[0]
        if s == "a":
            s = Sa[1]
            del Sa[0]
        elif s == "b":
            s = Sb[1]
            del Sb[0]
        else:
            s = Sc[1]
            del Sc[0]
    elif len(Sa) == 1 and s == "a":
        print("A")
        break
    elif len(Sb) == 1 and s == "b":
        print("B")
        break
    elif len(Sc) == 1 and s == "c":
        print("C")
        break
    else:
        if s == "a":
            s = Sa[1]
            del Sa[0]
        elif s == "b":
            s = Sb[1]
            del Sb[0]
        else:
            s = Sc[1]
            del Sc[0]


### FIXED CODE ###

Sa = list(input())
Sb = list(input())
Sc = list(input())
c = 0
for _ in range(10**9):
    if c == "a" and not Sa:
        print("A")
        break
    if c == "b" and not Sb:
        print("B")
        break
    if c == "c" and not Sc:
        print("C")
        break
    if _ == 0:
        c = Sa[0]
        del Sa[0]
    elif c == "a":
        c = Sa[0]
        del Sa[0]
    elif c == "b":
        c = Sb[0]
        del Sb[0]
    else:
        c = Sc[0]
        del Sc[0]
import sys
a = sys.stdin.readline()
b = sys.stdin.readline()
if a == b[:-1]:
  print "Yes"
else:
  print "No"

### FIXED CODE ###

import sys                       
a = sys.stdin.readline().rstrip()
b = sys.stdin.readline().rstrip()
if a == b[:-1]:                  
  print("Yes")                   
else:                            
  print("No")
N, T = map(int, input().split())
result = 1001
for _ in range(N):
    c, t = map(int, input().split())
    if t <= T:
        result = min(result, c)

if (result == 1001):
    print('TLE') 
else:
    print(result)

### FIXED CODE ###

if(1==int(input())):
  print('Hello World')
else:
  x,y=[int(input()) for i in range(2)]
  print(x+y)
a = [str(i) for i in range('a, z')]
a.upper()

### FIXED CODE ###

print(input().swapcase())
N = int(input())
S = list(map(int, input().split()))

if "Y" in S:
    print("Four")
else:
    print("Three")


### FIXED CODE ###

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

if "Y" in S:
    print("Four")
else:
    print("Three")
a, b= map(int, input().split())

if a-b*2<=0:
  print(0)
 else:
  print(a-b*2)

### FIXED CODE ###

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

c=a-b*2

if c<=0:
    print(0)
else:
    print(c)
n = int(input())
p = list(map(int, input().split(' ')))
p = sorted(p, reverse=True)

if p[0] < sum(p[1:]):
	print('Yes')
else:
	print('No')

### FIXED CODE ###


t, x = map(int, input().split(' '))
print(t/x)
# -*- coding: utf-8 -*-
# Nの取得
index = int(input('input num : '))
 
# n回ループして配列に入れる
maximum = 0
other = 0
inputList = input().split()
for i in range(index):
    tmp = int(inputList[i])
    if tmp > maximum:
        maximum = tmp
        other = other + maximum
    else:
        other = other + tmp
 
if maximum <= tmp - maximum :
    print("Yes")
else:
    print("No")

### FIXED CODE ###

# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
a,b = map(int, input().split())
# 出力
print(a/b)
A, B, C = list(map(int, input()))
K = int(input())

ans = max(A, B, C) * (2 ** K)

print(ans)

### FIXED CODE ###

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

ans = max([A, B, C]) * (2 ** K) - max([A, B, C])

print(ans + A + B + C)
N = int(input())
hList = [int(x) for x in input().split()]

def dfs(idx):
    if idx < N-2:
        return min(abs(hList[idx] - hList[idx+1]) + dfs(idx+1), abs(hList[idx] - hList[idx+2]) + dfs(idx+2))
    elif idx < N-1:
        return abs(hList[idx] - hList[idx+1]) + dfs(idx+1)
    else:
        return 0

print(dfs(0))

### FIXED CODE ###

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

#i番目まで飛んだ時点で一番小さい値、を計算していく
dp = [0, abs(hList[0] - hList[1])]
for i in range(2,N):
    dp.append(min(dp[i-2] + abs(hList[i-2] - hList[i]), dp[i-1] + abs(hList[i-1] - hList[i])))
print(dp[-1])
R,G=map(int,input().split())

print(2*G-R)

### FIXED CODE ###

r=int(input())
g=int(input())
print(2*g-r)
n,a,b = int(input().split())
ans = 0

for i in range(n+1):
    if a<= sum(list(map(int,list(str(i))))) <= b:
        ans += i:
print(ans)

### FIXED CODE ###

n,a,b=map(int,input().split())
s=0
for i in range(n+1):
    if a<=sum(list(map(int,str(i))))<=b:
        s+=i
print(s)
from collections import deque
H, W = map(int, input().split()) 
S = [list(input()) for i in range(R)]

Kuro = 0
Shiro = 0
for j in range(H):
    for i in range(W):
        if S[j][i]=='.':
            Shiro += 1
        else:
            Kuro += 1

Dis =[[0]*W for i in range(H)]
X =[-1, 0, 1, 0]
Y =[0, -1, 0, 1]
q = deque()
q.append((0,0))
while True:
    y,x = q.popleft()
    if (y==H-1) and (x==W-1):
        break
    for i in range(4):
        nx = x + X[i]
        ny = y + Y[i]
        if (0<= nx < W) and(0 <= ny < H) and (S[ny][nx]=='.') and(Dis[ny][nx] ==0):
            q.append((ny,nx))
            Dis[ny][nx] = Dis[y][x] +1

print(Shiro-Dis[H-1][W-1]-1)

### FIXED CODE ###

import sys
from collections import deque
sys.setrecursionlimit(10**8)

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

Kuro = 0
Shiro = 0
for j in range(H):
    for i in range(W):
        if S[j][i]=='.':
            Shiro += 1
Dis =[[-1]*W for i in range(H)]
X =[-1, 0, 1, 0]
Y =[0, -1, 0, 1]
q = deque()
q.append((0,0))
Dis[0][0] = 0
a=deque()
while (q != a):
    y,x = q.popleft()
    if (y==H-1) and (x==W-1):
        break
    for i in range(4):
        nx = x + X[i]
        ny = y + Y[i]
        if (0<= nx < W) and(0 <= ny < H) and (S[ny][nx]=='.') and (Dis[ny][nx] ==-1):
            q.append((ny,nx))
            Dis[ny][nx] = Dis[y][x] +1

if (Dis[H-1][W-1]==-1):
    print(-1)
else:
    print(Shiro-Dis[H-1][W-1]-1)
x,y,z = map(int,input().split())
print('{} {} {}').format(z,x,y)

### FIXED CODE ###

x,y,z = map(int,input().split())
print(z,' ',x,' ',y)
l, r = map(int, input().split())

l = l%2019
r = r%2019

list_score = []
for i in range(l+1, r+1):
    for j in range(i, r+1):
        list_score.append(i*j%2019)

print(int(min(list_score)))

### FIXED CODE ###

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

if r-l>=2019 :
    print(0)
    exit()

l = l%2019
r = r%2019

if l == 0 or r == 0 :
    print(0)
    exit()

if l > r:
    r += 2019

# print(l, r)

list_score = []
for i in range(l+1, r+1):
    for j in range(l, i):
        # print(i, j)
        list_score.append(i*j%2019)
# print(list_score)
print(int(min(list_score)))
num = int(input())
input_list = input().split()

i = 0
j = 1
tmp = 0L
score = 0L
while True:
    if j > (num - 1):
        break
    elif input_list[i] >= input_list[j]:
        tmp += 1
        i += 1
        j += 1
    else:
        if tmp > score:
            score = tmp
        tmp = 0
        i += 1
        j += 1
if tmp >= score:
    score = tmp
print(score)

### FIXED CODE ###

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

ans = 0
tmp = 0
before = H[0]
for i in range(1, N):
    if before >= H[i]:
        tmp += 1
        before = H[i]
    else:
        ans = max(ans, tmp)
        tmp = 0
        before = H[i]

print(max(ans,tmp))
import sys
ds = int(raw_input())
list =[long(x.strip()) for x in sys.stdin.readlines()]
print list
for i in xrange(ds):
    sum = str(list[i*2]+list[i*2+1])
    if len(sum) > 80:
        print "overflow"
    else:
        print sum

### FIXED CODE ###

ds = int(raw_input())
for i in xrange(ds):
    x=int(raw_input())
    y=int(raw_input())
    sum = str(x+y)
    if len(sum) > 80:
        print "overflow"
    else:
        print sum
N,Q = map(int,input().split())
event = []
for i in range(N):
    s,t,x = map(int,input().split())
    event.append((s-x,x,1))
    event.append((t-x,x,-1))

s = set()

event.sort()

for i in range(Q):
    D = int(input())
    while event:
        t,x,f = event.pop(0)
        if D < t:
            break
        if f == 1:
            s.add(x)
        else:
            s.remove(x)
    if len(s)==0:
        print(-1)
    else:
        print(min(s))
    if D < t:
        if f == 1:
            s.add(x)
        else:
            s.remove(x)

### FIXED CODE ###

from bisect import bisect_left as bisect
N,Q = map(int,input().split())
event = [tuple(map(int,input().split())) for i in range(N)]
D = [int(input()) for i in range(Q)]

event.sort(key=lambda x:x[2])

ans = [-1]*Q
neg = [-1]*Q

for s,t,x in event:
    l = bisect(D,s-x)
    r = bisect(D,t-x)
    t = l
    while t < r:
        if neg[t] == -1:
            ans[t] = x
            neg[t] = r
            t += 1
        else:
            t = neg[t]

for i in range(Q):
    print(ans[i])
import math
r = input()
s =2*math.pi*r
v =math.pi*r^2

print(s,v)


### FIXED CODE ###

import math
r = float(input())
v = math.pi*r*r
s = math.pi*r*2

print('%.7f %.7f'%(v,s))
import collections

N = int(input())
a = [int(i) for i in input().split(" ")]
c = collections.Counter(a)
ans = 0

for key,val in c.items():
    del = max(val-key,val)
    if key == val:
        del = 0
    ans += del

print(ans)


### FIXED CODE ###

import collections

N = int(input())
a = [int(i) for i in input().split(" ")]
c = collections.Counter(a)
ans = 0

for key,val in c.items():
    d = val
    if val >= key:
        d = min(val-key,val)
    ans += d

print(ans)
import numpy as np
n=int(input())
a=[int(x) for x in input().split()]

matrix=np.zeros((n,n))

for i in range(n-1):
  matrix[i,i:i+2]+=1
matrix[-1,0]+=1
matrix[-1,-1]+=1

#A = np.array([[1.,3.] ,[4.,2.]])
#B = np.array([1.,1.])   # 行列Bの生成

X = np.linalg.solve(matrix, np.array(a)).tolist()
# 計算結果の表示
print(*[int(2*item) for item in X])


### FIXED CODE ###

from scipy.sparse import csr_matrix
from scipy.sparse.linalg import spsolve
import numpy as np

N = int(input())
A = np.array(input().split())

#値の入る座標の準備
rows = np.concatenate([np.arange(N), np.arange(N)])
cols = np.concatenate([np.arange(N), np.arange(1,N+1) % N])

#疎行列の作成
#csr_matrix((値だけのlist, 値の入る座標を示すtulpe:(rows, cols) ), 大きさ (N,N))
mat = csr_matrix(([1] * (2*N), (rows, cols)), (N,N))
#print(rows,cols,mat)
 
answer = (spsolve(mat,A) * 2).astype(int)
print(*answer)
n = int(input())
a = list(map(int,input().split()))
a.sort()
dp = [0 for i in range(a[-1])]
p = [0 for i in range(a[-1])]
for i in range(n):
    p[a[i]-1] = 1
ans = 1
for i in range(2,a[-1]+1):
    if dp[i-1] == 1:
        continue
    u = 0
    k = 1
    while i*k <= a[-1]:
        dp[i*k-1] = 1
        if p[i*k-1] == 1:
            u += 1
        k += 1
    if u == n:
        ans = -1
    elif u > 1:
        ans = min(ans,0)
elif ans == 1:
    print('pairwise coprime')
elif ans == 0:
    print('setwise coprime')
elif a[0] == 1:
    print('setwise coprime')
else:
    print('not coprime')

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
a.sort()
dp = [0 for i in range(a[-1])]
p = [0 for i in range(a[-1])]
for i in range(n):
    p[a[i]-1] += 1
ans = 1
for i in range(2,a[-1]+1):
    if dp[i-1] == 1:
        continue
    u = 0
    k = 1
    while i*k <= a[-1]:
        dp[i*k-1] = 1
        if p[i*k-1] != 0:
            u += p[i*k-1]
        k += 1
    if u == n:
        ans = -1
    elif u > 1:
        ans = min(ans,0)
if ans == 1:
    print('pairwise coprime')
elif ans == 0:
    print('setwise coprime')
elif a[0] == 1:
    print('setwise coprime')
else:
    print('not coprime')
import collections

class UnionFind:
    def __init__(self, N, M):
        self.N = N
        self.M = M
        self.parent = [i for i in range(N+1)]
        self.count = [1 for _ in range(N+1)]

    def find(self, i):
        if self.parent[i] != i:
            self.parent[i] = self.find(self.parent[i])
        return self.parent[i]

    def union(self, i, j):
        pi, pj = self.find(i), self.find(j)
        if pi != pj:
            self.parent[pj] = pi
            self.count[pi] += self.count[pj]

    def isConnected(self, i, j):
        return self.find(i) == self.find(j)

def main():
    N, M = map(int, input().split())
    bridges = []
    for _ in range(M):
        a, b = map(int, input().split())
        bridges.append([a, b])

    UF = UnionFind(N, M)

    ans = [N*(N-1)//2]
    for i in range(M-1, 0, -1):
        a, b = bridges[i]
        if UF.isConnected(a, b):
            ans.append(ans[-1])
        else:
            ans.append(ans[-1]- UF.count[UF.find(a)]*UF.count[UF.find(b)])
            UF.union(a, b)
    return ans

if __name__ == '__main__':
    output = main()
    for i in range(len(output)-1, -1, -1):
        print(output[i])

### FIXED CODE ###

import collections
def main():
    N, M = map(int, input().split())
    bridges = []
    for _ in range(M):
        a, b = map(int, input().split())
        bridges.append([a, b])
    bridges = bridges[::-1]
    parent = [i for i in range(N+1)]
    count = dict()
    for i in range(N+1): count[i] = 1

    def find(i):
        if parent[i] != i:
            parent[i] = find(parent[i])
        return parent[i]

    def union(i, j):
        pi, pj = find(i), find(j)
        df = 0
        if pi != pj:
            if count[pi] > count[pj]:
                parent[pj] = pi
                df += count[pi] * count[pj]
                count[pi] += count[pj]
                del count[pj]
            else:
                parent[pi] = pj
                df += count[pi] * count[pj]
                count[pj] += count[pi]
                del count[pi]                
        return df

    ans = [N*(N-1)//2]
    for a, b in bridges[:-1]:
        d = union(a, b)
        ans.append(ans[-1]-d)
    return ans[::-1]

if __name__ == '__main__':
    output = main()
    for v in output:
        print(v)
# n,aを入力
n, a = map(int, input().split())
# nを500で割った余りを計算
if n % 500 == 0:
    print('Yes')
elif (n % 500) == a:
    print('yes')
else:
    print('No')
    


### FIXED CODE ###

N = int(input())
A = int(input())
if (N % 500) > A:
  print('No')
else:
  print('Yes')
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = True

n = INT()
s = list(STR())
t = list(set(s))
u = Counter(s)
v = []
for i in t:
    v.append(u[i] + 1)
ans = 1
for i in range(len(t)):
    ans *= v[i]
    ans %= mod
ans -= 1
print(ans %= mod)

### FIXED CODE ###

import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def debug(*args):
    if debugmode:
        print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = True

n = INT()
s = list(STR())
t = list(set(s))
u = Counter(s)
v = []
for i in t:
    v.append(u[i] + 1)
ans = 1
for i in range(len(t)):
    ans *= v[i]
    ans %= mod
ans -= 1
print(ans % mod)
if X >= 30:
  print('Yes')
else :
  print('No')


### FIXED CODE ###

X = int(input())
if X >= 30:
    print('Yes')
else:
    print('No')
n = int(input())
a = list(map(int, input().split()))

if n == 3 and a[0] ^ a[1] == a[2]:
  print("Yes")
elif n >= 4 and set(a) = set([1]):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

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

st = set(a)
lst = list(st)

if n == 3 and a[0] ^ a[1] == a[2]:
  print("Yes")
elif n  >= 4 and st == {0}:
  print("Yes")
elif n % 3 == 0 and len(st) == 2 and a.count(0) == n /3:
  print("Yes")
elif n % 3 == 0 and len(st) == 3 and lst[0] ^ lst[1] == lst[2] and a.count(lst[0]) == n /3 and a.count(lst[1]) == n/3:
  print("Yes")
else:
  print("No")
n = int(input()) #1行目のNを取得する
s = [int(input() for i in range(n))] #複数行の数値の入力を取得

for i in range (n):
    a = s.pop(0)
    ans = max(s)
    print(ans)
    s.append(a)

### FIXED CODE ###

n = int(input()) #1行目のNを取得する
list = [input() for i in range(n)] #複数行の数値の入力を取得
lint = [int(s) for s in list]

ans = max(lint)
index = lint.index(max(lint))
lint.remove(max(lint))
ans2 = max(lint)

if ans == ans2:
    for i in range(n):
        print(ans)
else:
    for i in range(0, index):
        print(ans)
    print(ans2)
    for i in range(index+1, n):
        print(ans)
l = []
ans = []
a, b, k = list(map(int, input().split()))
l.append(a)
l.append(b)
i = 1

for i in range(1, max(l)):
    if (a % i) == 0 and (b % i) == 0:
       ans.append(i) 

if len(ans) == 0:
    print(1)
else:
    print(ans[-k])


### FIXED CODE ###

l = []
ans = []
a, b, k = list(map(int, input().split()))
l.append(a)
l.append(b)
i = 1

for i in range(1, min(l) + 1):
    if (a % i) == 0 and (b % i) == 0:
       ans.append(i) 

if len(ans) == 0:
    print(1)
else:
    print(ans[-k])
x, y, z = map(input().split(,))
print(x y z)

### FIXED CODE ###

x, y, z = input().split(",")
print(x, y, z)
n = int(input())
a = int(input())
b = int(input())
if n == 1:
  print('Hello World')
else:
  print(a+b)

### FIXED CODE ###

n = int(input())
if n == 1:
  print('Hello World')
else:
  a = int(input())
  b = int(input())
  print(a+b)
a, b = [int(x) for x in input().split()]

return a * b - a - b + 1

### FIXED CODE ###

a, b = [int(x) for x in input().split()]
 
print(a * b - a - b + 1)
if D=23:
    print('Christmas Eve Eve')

if D=24:
    print('Christmas Eve')

if D=23:
    print('Christmas ')


### FIXED CODE ###

D = int(input())

if D==22:
    print ("Christmas Eve Eve Eve")

if D==23:
    print ("Christmas Eve Eve")

if D==24:
    print ("Christmas Eve")

if D==25:
    print ("Christmas ")
a,b = map(int,input().split())
d = b-a

def h(x:int):
    if x == 1:
        return 1
    else:
        return h(x-1)+x

print (h(d)-b)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 9)

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

def h(x:int):
    if x == 1:
        return 1
    else:
        return h(x-1)+x

print (h(d)-b)
import bisect
n = int(input())
h = list(map(int, input().split()))
h.sort()
x = 0
def triangle(n,h):
    for i in range(0,n-2):
        for j in range(i+1,n-1):
            for k in range(j+1, n):
                if h[k] <= h[j] + h[i] :
                    x = x + 1
    return x
print(triangle(n,h))

### FIXED CODE ###

import bisect
N = int(input())
#ソートしておく
L = sorted(list(map(int, input().split())))
ans = 0
 
#短い2辺を総当たりで選択
for i in range(N - 2):
  for j in range(i + 1, N - 1):
    #小さい順に並べた時の成立条件
    # l1 + l2 > l3
    l12 = L[i] + L[j]
    #l2の隣から　l12以下のところまで全部が対象、成立しない場合
    #ans += max(bisect.bisect_left(L, l12) - j - 1, 0)
    ans += bisect.bisect_left(L, l12) - j - 1
print(ans)
S=input()
if S="A":
  print("T")
elif S="T":
  print("A")
elif S="G":
  print("C")
else:
  print("G")

### FIXED CODE ###

S=input()
if S=="A":
  print("T")
elif S=="T":
  print("A")
elif S=="G":
  print("C")
else:
  print("G")
n=int(input())
ans=[0]*(10001)
for i in range(1,101):
  for j in range(1,101):
    for k in range(1,101):
      index=i**2+j**2+k**2+i*j+j*k+i*k
      if index<10000:
        ans[index]+=1
     
for i in range(1,n+1):
  print(ans[i])


### FIXED CODE ###

l,r,d=map(int,input().split())
if l%d!=0:
  print(r//d-l//d)
else:
  print((r//d-l//d)+1)
N, M = map(int, input().split())
Costs = {1: 2, 2: 5, 3: 5, 4: 4, 5: 5, 6: 6, 7: 3, 8: 7, 9: 6}
A = sorted(list(map(int, input().split())), reverse=True)  # 大きい順に


# dp[i]:= マッチ棒をn本使って得られる最大桁数(-infはマッチ棒が使いきれないことを表す)
dp = [-float('inf')] * (N + 1)
dp[0] = 0

# 蟻本P.60みたいなことをします
for i in range(M):
    cost = Costs[A[i]]
    for j in range(N + 1):
        if cost > j:
            continue
        dp[j] = max(dp[j], dp[j - cost] + 1)


# dpの復元
ans = ""
marker = N  # いま何本残っているか
while dp[marker] > 0:  # 0本になるまで回す
    for a in A:  # 大きな数字から見ていく
        cost = Costs[a]
        # marker本ある状態から、マッチ棒をcost本使う数字aを使わなければ、marker本使った場合の桁数-1になる場合、
        # 数字aを使ったことがわかる
        if dp[marker - cost] == dp[marker] - 1:
            ans += str(a)
            marker = marker - cost
            break

print(ans)


### FIXED CODE ###

N, M = map(int, input().split())
Costs = {1: 2, 2: 5, 3: 5, 4: 4, 5: 5, 6: 6, 7: 3, 8: 7, 9: 6}
A = sorted(list(map(int, input().split())), reverse=True)  # 大きい順に


# dp[i]:= マッチ棒をn本使って得られる最大桁数(-infはマッチ棒が使いきれないことを表す)
dp = [-float('inf')] * (N + 1)
dp[0] = 0

# 個数制限なしナップサックと同じ要領
for a in A:
    cost = Costs[a]
    for j in range(N + 1):
        if cost > j:
            continue
        dp[j] = max(dp[j], dp[j - cost] + 1)


# dpの復元
ans = ""
marker = N  # いま何本残っているか
while dp[marker]:  # 0本になるまで回す
    for a in A:  # 大きな数字から見ていく
        cost = Costs[a]
        
        # Python特有のバグ消し
        if marker - cost < 0:
            continue
        
        # marker本ある状態から、マッチ棒をcost本使う数字aを使わなければ、marker本使った場合の桁数-1になる場合、
        # 数字aを使ったことがわかる
        if dp[marker - cost] == dp[marker] - 1:
            ans += str(a)
            marker = marker - cost
            break

print(ans)
n=int(input())
string_list=[input() for i in range(n)]
a = int(string_list[0])
if a <= 3200:
  print("red")
else:
  print(a[1])
  

### FIXED CODE ###

n=input()
m=input()

if int(n) < 3200:
  print("red")
else:
  print(m)