Harryxun/stf_run huggingface dataset:
# -*- coding: utf-8 -*-
import numpy as np
inputs = input().split()
A = int(inputs[0])
B = int(inputs[1])
K = int(inputs[2])


if A + K < B - K:
    candidates = np.concatenate(np.arange(A, A + K), np.arange(B - K, B))
else:
    candidates = np.arange(A, B + 1)
    candidates = candidates[np.logical_or(candidates < A + K, candidates > B - K)]

for s in np.sort(candidates):
    print(s)


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
inputs = input().split()
A = int(inputs[0])
B = int(inputs[1])
K = int(inputs[2])


if A + K < B - K:
    candidates = np.concatenate([np.arange(A, A + K), np.arange(B - K + 1, B + 1)])
else:
    candidates = np.arange(A, B + 1)
    candidates = candidates[np.logical_or(candidates < A + K, candidates > B - K)]

for s in candidates:
    print(s)
N = int(input())
V = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
P = [V[x]-C[x] for x in range(N)]

P = sorted(P)[::-1]
i,ans = 0,0

while P[i] > 0:
    ans += P[i]
    i += 1
print(ans)

### FIXED CODE ###

N = int(input())
V = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
P = [V[x]-C[x] for x in range(N)]

P = sorted(P)[::-1]
i,ans = 0,0

while P[i] > 0:
    ans += P[i]
    i += 1
    if i == N:
        break
print(ans)
from math import cos, sin, sqrt, radians
short = int(input())
long = int(input())
hour = int(input())
minit = int(input())

short_kaku = 90 - (30 * hour + 0.5 * minit)
short_x = short * cos(radians(short_kaku))
short_y = short * sin(radians(short_kaku))

long_kaku = 90 - 6 * minit
long_x = long * cos(radians(long_kaku))
long_y = long * sin(radians(long_kaku))

distance = sqrt((short_x - long_x) ** 2 + (short_y - long_y) ** 2)

print(distance)

### FIXED CODE ###

from math import cos, sin, sqrt, radians
short, long, hour,minit = map(int,input().split())

short_kaku = 90 - (30 * hour + 0.5 * minit)
short_x = short * cos(radians(short_kaku))
short_y = short * sin(radians(short_kaku))

long_kaku = 90 - 6 * minit
long_x = long * cos(radians(long_kaku))
long_y = long * sin(radians(long_kaku))

distance = sqrt((short_x - long_x) ** 2 + (short_y - long_y) ** 2)

print(distance)
import math
N,K = map(int,input().split())
r = 0
for i in range(1,N+1):
    if i>=K:
        continue
    else:
        l = math.ceil(math.log2(K / i))
        r += ((1 / 2) ** l)/N
print(float(r))



### FIXED CODE ###

import math
N,K = map(int,input().split())
r = 0
for i in range(1,N+1):
    if i >= K:
        r += 1/N
    else:
        l = math.ceil(math.log2(K / i))
        r += ((1 / 2) ** l)/N
print(r)
s = input()
ans = 0
tmp = 0
acgt = ['A', 'C', 'G', 'T']
while s:
  if s.pop(0) in acgt:
    tmp += 1
  else:
    ans = max([ans, tmp])
    tmp = 0

ans = max([ans, tmp])
print(ans)

### FIXED CODE ###

s = [i for i in input()]
ans = 0
tmp = 0
acgt = ['A', 'C', 'G', 'T']
while s:
  if s.pop(0) in acgt:
    tmp += 1
  else:
    ans = max([ans, tmp])
    tmp = 0

ans = max([ans, tmp])
print(ans)
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X,Y,A,B,C = map(int,readline().split())
P = list(map(int,readline().split()))
Q = list(map(int,readline().split()))
R = list(map(int,readline().split()))
P = sorted(P,reverse=True)
Q = sorted(Q,reverse=True)
R = sorted(R,reverse=True)
P = P[:X]
Q = Q[:Y]
PQ = sorted(P+Q,reverse = True)
XY = X+Y
total = sum(PQ)
for i in range(C):
    if R[i] < PQ[-(i+1)]:
      if i == 0:
        ans = total
      else:
        ans = total + sum(R[:i]) - sum(PQ[-i:])
      break
    if i == C-1:
      ans = total + sum(R[:i+1]) - sum(PQ[-(i+1):])
print(ans)

### FIXED CODE ###

import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
X,Y,A,B,C = map(int,readline().split())
P = list(map(int,readline().split()))
Q = list(map(int,readline().split()))
R = list(map(int,readline().split()))
P = sorted(P,reverse=True)
Q = sorted(Q,reverse=True)
R = sorted(R,reverse=True)
P = P[:X]
Q = Q[:Y]
PQR = sorted(P+Q+R,reverse = True)
ans = sum(PQR[:X+Y])
print(ans)
n = int(input())
a = map(int, input().split())
occur = [0 for i in range(n + 1)]
x = 0
cnt = 0
for i in a:
    cnt += 1
    if (occur[i] > 0):
        x = n + 1 - cnt + occur[i]
    else:
        occur[i] = cnt
print(n)
res1 = n + 1
res2 = 1
for i in range(1, n + 1):
    res1 = res1 * (n + 1 - i) / (i + 1)
    if (res2 >= 1): res2 = res2 * (x - i) / i
    print(int((res1 - res2 + 1000000007) % 1000000007))


### FIXED CODE ###

n = int(input())
a = tuple(map(int, input().split()))
occur = [0 for i in range(n + 1)]
MOD = 1000000007
for i in range(n + 1):
    if occur[a[i]] > 0: val = n - 1 - i + occur[a[i]]
    else: occur[a[i]] = i + 1
inv = [0 if i > 2 else 1 for i in range(n + 2)]
pinv = [0 if i > 2 else 1 for i in range(n + 2)]
perm = [0 if i > 2 else 1 for i in range(n + 2)]
for i in range(2, n + 2):
    inv[i] = -int(MOD / i) * inv[MOD % i] + MOD
    pinv[i] = pinv[i - 1] * inv[i] % MOD
    perm[i] = perm[i - 1] * i % MOD
def C(n, m):
    return (perm[m] * pinv[n] % MOD) * pinv[m - n] % MOD if n <= m else 0
for i in range(1, n + 2):
    temp = C(i, n + 1) - C(i - 1, val)
    if temp < 0: temp += MOD
    print(temp)
H, W, N, sr, sc, S, T = open('0').read().split()
H, W, N, sr, sc = map(int, (H,W,N,sr,sc))
dpr = [0]*N
dpl = [0]*N
dpu = [0]*N
dpd = [0]*N
dpr[0] = W-sr
dpl[0] = sr
dpu[0] = sc
dpd[0] = H-sc
for i in range(N-1):
  if T[i]=='R':
    dpl[i+1] = min(W-1,dpl[i]+1)
    dpr[i+1] = dpr[i]
    dpd[i+1] = dpd[i]
    dpu[i+1] = dpu[i]
  elif T[i]=='L':
    dpr[i+1] = min(W-1,dpr[i]+1)
    dpl[i+1] = dpl[i]
    dpu[i+1] = dpu[i]
    dpd[i+1] = dpd[i]
  elif T[i]=='U':
    dpd[i+1] = min(H-1,dpd[i]+1)
    dpl[i+1]= dpl[i]
    dpu[i+1] = dpu[i]
    dpd[i+1] = dpd[i]
  else:
    dpu[i+1] = min(H-1,dpu[i]+1)
    dpl[i+1] = dpl[i]
    dpr[i+1] = dpr[i]
    dpd[i+1] = dpd[i]
sdpr = [0]*(N+1)
sdpl = [0]*(N+1)
sdpu = [0]*(N+1)
sdpd = [0]*(N+1)
for i in range(N):
  if S[i]=='R':
    sdpr[i+1] = sdpr[i]+1
    if sdpr[i+1]>dpr[i]:
      print('NO')
      break
  elif S[i]=='D':
    sdpd[i+1] = sdpd[i]+1
    if sdpd[i+1]>dpd[i]:
      print('NO')
      break
  elif S[i]=='L':
    sdpl[i+1] = sdpl[i]+1
    if sdpl[i+1]>dpl[i]:
      print('NO')
      break
  else:
    sdpu[i+1] = sdpu[i]+1
    if sdpu[i+1]>dpu[i]:
      print('NO')
      break
else:
  print('YES')

### FIXED CODE ###

H, W, N, sr, sc, S, T = open(0).read().split()
H, W, N, sr, sc = map(int, (H,W,N,sr,sc))
dpr = [0]*(N+1)
dpl = [0]*(N+1)
dpu = [0]*(N+1)
dpd = [0]*(N+1)
dpr[0] = W-sc
dpl[0] = sc-1
dpu[0] = sr-1
dpd[0] = H-sr
for i in range(N):
  if S[i]=='R':
    dpr[i] -= 1
    if 0>dpr[i]:
      print('NO')
      break
  elif S[i]=='D':
    dpd[i] -= 1
    if 0>dpd[i]:
      print('NO')
      break
  elif S[i]=='L':
    dpl[i] -= 1
    if 0>dpl[i]:
      print('NO')
      break
  else:
    dpu[i] -= 1
    if 0>dpu[i]:
      print('NO')
      break
  if T[i]=='R':
    dpl[i+1] = min(W-1,dpl[i]+1)
    dpr[i+1] = dpr[i]
    dpd[i+1] = dpd[i]
    dpu[i+1] = dpu[i]
  elif T[i]=='L':
    dpr[i+1] = min(W-1,dpr[i]+1)
    dpl[i+1] = dpl[i]
    dpu[i+1] = dpu[i]
    dpd[i+1] = dpd[i]
  elif T[i]=='U':
    dpd[i+1] = min(H-1,dpd[i]+1)
    dpl[i+1]= dpl[i]
    dpu[i+1] = dpu[i]
    dpr[i+1] = dpr[i]
  else:
    dpu[i+1] = min(H-1,dpu[i]+1)
    dpl[i+1] = dpl[i]
    dpr[i+1] = dpr[i]
    dpd[i+1] = dpd[i]
else:
  print('YES')
N, M = map(int,input().split())
A = [0 for _ in range(N)]

abc = [(A[i],1) for i in range(N)]

for j in range(M):
    B, C = map(int, input().split())
    abc.append((C,B))
    
abc.sort()
abc.reverse()

ans = 0
cnt = N

for (c,b) in abc:
    num_c = min(b,cnt)
    ans += num_c * c
    cnt -= num_c

print(ans)

### FIXED CODE ###

N, M = map(int,input().split())
A = [int(a) for a in input().split()]
BC = [[0,0] for _ in range(M)]

for i in range(M):
    B,C = map(int,input().split())
    BC[i] = [B,C]

a_use = sorted(A)
bc_use = sorted(BC, reverse=True, key=lambda x: x[1])

low_index = 0
for i in range(M):
    if low_index > N-1:
        break
    if a_use[low_index] > bc_use[i][1]:
        break
    else:
        for j in range(bc_use[i][0]):
            if j + low_index > N-1:
                break
            if a_use[j+low_index] < bc_use[i][1]:
                a_use[j+low_index] = bc_use[i][1]
        low_index += bc_use[i][0]

print(int(sum(a_use)))
# -*- coding: utf-8 -*-

N,X,M=map(int,input().split())

A=[0]*M
A[0]=X
D=[0]*M

s=N
for i in range(1,N):
    a=A[i-1]**2%M
    if D[a] == 1:
        s=A.index(a)
        break
    else:
        A[i]=a
        D[a]=1

if s==N:
    ans=sum(A[:i])
else:
    A=A[:i]
    
    ans=0
    l=len(A)-s
    ans+=sum(A[:s])
    S=sum(A[s:])
    T=(N-s)//l
    ans+=T*S
    K=N-s-l*T
    ans+=sum(A[s:(s+K)])


print(ans)


### FIXED CODE ###

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

N,X,M=map(int,input().split())

A=[0]*10**5
A[0]=X
D=dict()
#A=[X]
s=N
for i in range(1,N):
    a=A[i-1]**2%M
    if a in D:
        s=A.index(a)
        break
    else:
        #A.append(a)
        A[i]=a
        D[a]=0

if s==N:
    ans=sum(A)
else:
    A=A[:i]
    Z=[0]*(len(A)+1)
    for i in range(1,len(A)+1):
        Z[i]=Z[i-1]+A[i-1]  

    ans=0
    l=len(A)-s
    #ans+=sum(A[:s])
    ans+=Z[s]
    #S=sum(A[s:])
    S=Z[len(A)]-Z[s]
    T=(N-s)//l
    ans+=T*S
    K=N-s-l*T
    #ans+=sum(A[s:(s+K)])
    ans+=Z[s+K]-Z[s]


print(ans)
import math

n = int(input())
a = [int(x) for x in input().split(" ")]
g = a.sort()[n - 1]

for i in range(1, n):
    g = math.gcd(g, a[i])
    
print(g)

### FIXED CODE ###

def gcd(a, b):
    while b != a:
        if a < b:
            b = b % a
            if b == 0:
                return a
        elif b < a:
            a = a % b
            if a == 0:
                return b
    return a

def m(a):
    a.sort()
    l = len(a)
    b = []
    for i in range(l // 2):
        b.append(gcd(a[i], a[l - i - 1]))
    if l % 2 == 1:
        b.append(a[l // 2])
    return list(set(b))

    
n = int(input())
a = [int(x) for x in input().split(" ")]

while len(a) > 1:
    a = m(a)

print(a[0])
p,a=1,0
n=input()
for i in list(map(int,input().split())):
  if p<=i:ans+=1
  p=i
print(a)

### FIXED CODE ###

p,a=1,0
n=input()
for i in list(map(int,input().split())):
  if p<=i:a+=1
  p=max(i,p)
print(a)
s=input()
st=s.index('A')
t=s
t.reverse()
en=t.index('Z')
print(len(s)-st-en)

### FIXED CODE ###

s=input()
st=s.index('A')
t=s[::-1]
en=t.index('Z')
print(len(s)-st-en)
H, W = map(int, input().split())
C = [input() for _ in range(H)]
for i in raneg(2*H):
  print(C[i//2])


### FIXED CODE ###

H, W = map(int, input().split())
C = [input() for _ in range(H)]
for i in range(2*H):
  print(C[i//2])
question="C"
input=raw_input
if question=="A":
	t=input()
	t=t.replace("9","n")
	t=t.replace("1","o")
	t=t.replace("n","1")
	t=t.replace("o","9")
	print(t)
if question=="B":
	s=int(input())
	t=[111,222,333,444,555,666,777,888,999]
	t=filter(lambda x:x>=s,t)[0]
	print(t)
if question=="C":
	input()
	a=input().split()
	A=Amoto=a[0:][::2]
	B=Bmoto=a[1:][::2]
	def f(x):
		a=[(i, x.count(i)) for i in set(x)]
		a=sorted(a,key=lambda x:-x[1])
		return a
	A=f(A)
	B=f(B)
	if A[0][1]<B[0][1]:
		A,B=B,A
	A=A[0][0]
	B.append(("X",0))
	B=filter(lambda x:(x[0]!=A),B)[0][0]
	print sum(i!=A for i in Amoto) + sum(i!=B for i in Bmoto)
if question=="D":
	pass
if question=="E":
	pass

### FIXED CODE ###

question="A"
input=raw_input
if question=="A":
	t=input()
	t=t.replace("9","n")
	t=t.replace("1","o")
	t=t.replace("n","1")
	t=t.replace("o","9")
	print(t)
if question=="B":
	pass
if question=="C":
	pass
if question=="D":
	pass
if question=="E":
	pass
a, b = map(int, raw_input().split())
if a > b:
    print 'a > b'
elif a == b:
    print 'a == b'
else
    print 'a < b'

### FIXED CODE ###

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

if a>b:
  print "a > b"
if a<b:
  print "a < b"
if a==b:
  print "a == b"
def main():
    N = int(input())
    ls = [[int(x) for x in input().split()] for _ in range(N)]
    ans = 0
    for i in range(N):
        ls[i].append(ls[i][0]+ls[i][1])
    ls = sorted(ls,key=lambda x:-x[2])
    if N==1:
        print(ls[0][1])
    for i in range(N):
        ans -= ls[i][1]

    for i in range(N//2):
        ans += ls[2*i][2]

    if N%2==1:
        ans += ls[2*i+2][2]
    
    print(ans)
if __name__ == '__main__':
    main()

### FIXED CODE ###

def main():
    N = int(input())
    ls = [[int(x) for x in input().split()] for _ in range(N)]
    ans = 0
    for i in range(N):
        ls[i].append(ls[i][0]+ls[i][1])
    ls = sorted(ls,key=lambda x:-x[2])
    if N==1:
        print(ls[0][1])
        exit()
    for i in range(N):
        ans -= ls[i][1]

    for i in range(N//2):
        ans += ls[2*i][2]

    if N%2==1:
        ans += ls[2*i+2][2]
    
    print(ans)
if __name__ == '__main__':
    main()
import math
import fractions
import numpy

np.set_printoptions(suppress=True)


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

G = C * D / fractions.gcd(C,D)

ans = int( B // C - (A-1) // C ) + int(B // D - (A-1) // D) - int(B // G - (A-1) // G)

print (B - A + 1 - ans)


### FIXED CODE ###

from decimal import Decimal

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


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

G = C * D / gcd(C,D)

#print('{:.100g}'.format(G))

ans = ( B // C - (A-1) // C ) + (B // D - (A-1) // D) - (B // G - (A-1) // G)

print ('{:.100g}'.format(B - A + 1 - ans))
n=int(input())
s=int(input())
if n==s:
  print(n+1)
  exit()
for b in range(2,int(n**(1/2)+1)):
  m=n
  wa=0
  while m>0:
    wa+=m%b
    m=m//b
  if wa==s:
    print(b)
    exit()

for p in range(int(n**(1/2)),0,-1):
  if (n-s)%p==0:
    b=(n-s)//p+1
    if p+n%b==s:
      print(b)
      exit()
print('-1')


### FIXED CODE ###

n=int(input())
s=int(input())
if n==s:
  print(n+1)
  exit()
if n<s:
  print(-1)
  exit()
for b in range(2,int(n**(1/2))+1):
  m=n
  wa=0
  while m>0:
    wa+=m%b
    m=m//b
  if wa==s:
    print(b)
    exit()

for p in range(int((n-1)**(1/2)),0,-1):
  if (n-s)%p==0:
    b=(n-s)//p+1
    if p+n%b==s:
      print(b)
      exit()
print(-1)
from functools import reduce
from fractions import gcd
n,x=map(int,input().split())
x=[abx(x-int(i)) for i in input().split()]
print(reduce(gcd,x))

### FIXED CODE ###

from functools import reduce
from fractions import gcd
N,X=map(int,input().split())
x=[abs(X-int(i)) for i in input().split()]
print(reduce(gcd,x))
N = int(input())
a = [int(input()) for _ in range(N)]
count = 0
i = 1
x = 0
osita = [0]*N
while 2 not in osita and count < N + 10:
    osita[x] = i
    i = a[i-1]
    count += 1
    x += 1
    
if count > N:
    print(-1)
else:
    print(count-1)

### FIXED CODE ###

N = int(input())
a = [int(input()) for _ in range(N)]
count = 0
i = 1
x = 0
osita = [0]*(N+1)
for b in range(N+1):
    osita[b] = i
    i = a[i-1]
    
if 2 in osita:
    print(osita.index(2))
else:
    print(-1)
from math import sqrt
A,B = map(int,input().split())
dA = set([A])
dB = set([B])
r = int(sqrt(max(A,B))) + 1
for i in range(1,r+1):
    if A % i == 0:
        dA.add(i)
    if B % i == 0:
        dB.add(i)
CD = dA & dB

m = max(CD)
flg = [True] * (m+1)
flg[0] = False
for i in range(2,m+1):
    if i not in CD: flg[i] = False
    if flg[i]:
        t = i
        i += t
        while i <= m:
            flg[i] = False
            i += t

print(sum(flg))

### FIXED CODE ###

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

from fractions import gcd
g = gcd(A,B)

a = [1]
while g % 2 == 0:
    a.append(2)
    g //= 2
f = 3
while f * f <= g:
    if g % f == 0:
        a.append(f)
        g //= f
    else:
        f += 2
if g != 1:
    a.append(g)

print(len(set(a)))
import math
N = int(input())
ans = float("inf")

for i in range(1,int(math.sqrt(N))):
    if N%i == 0:
        ans = min(ans,i+N//i-2)
print(int(ans))


### FIXED CODE ###

import math
N = int(input())
ans = float("inf")

for i in range(1,int(math.sqrt(N))+1):
    if N%i == 0:
        ans = min(ans,i+N//i-2)
print(int(ans))
S=input()
TF=1
if len(S)%2==0:
    for i in range(len(S)/2):
        if S[2*i]!='h' or S[2*i+1]!='i':
            TF=0
        else:
            TF*=1
else:
    TF=0

if TF==0:
    print('No')
else:
    print('Yes')

### FIXED CODE ###

S=input()
if S in ['hi','hihi','hihihi','hihihihi','hihihihihi']:
    print('Yes')
else:
    print('No')
H,W = list(map(int,input().split()))

a = [input() for i in range(H)]

b = [[] for i in range(H)]
r = [[] for i in range(H)]
for i in range(H):
    for j in range(W):
        if i==0:
            b[i].append("#")
            r[i].append(".")
        elif i==H-1:
            b[i].append(".")
            r[i].append("#")
        elif S[i][j]=="#":
            b[i].append(".")
            r[i].append("#")
        elif j%2==0:
            b[i].append(".")
            r[i].append("#")
        elif j%2==1:
            b[i].append("#")
            r[i].append(".")

for i in range(H):
    ans = ""
    for j in range(W):
        ans = ans+b[i][j]

    print(ans)
print("")

for i in range(H):
    ans = ""
    for j in range(W):
        ans = ans+r[i][j]

    print(ans)

### FIXED CODE ###

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

a = [input() for i in range(H)]

b = [[] for i in range(H)]
r = [[] for i in range(H)]
for i in range(H):
    for j in range(W):
        if i==0:
            b[i].append("#")
            r[i].append(".")
        elif i==H-1:
            b[i].append(".")
            r[i].append("#")
        elif a[i][j]=="#":
            b[i].append("#")
            r[i].append("#")
        elif j%2==0:
            b[i].append(".")
            r[i].append("#")
        elif j%2==1:
            b[i].append("#")
            r[i].append(".")

for i in range(H):
    ans = ""
    for j in range(W):
        ans = ans+b[i][j]

    print(ans)
print("")

for i in range(H):
    ans = ""
    for j in range(W):
        ans = ans+r[i][j]

    print(ans)
import numpy as np
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    s=STR()
    count=np.zeros(2019,dtype=int)
    ans=0
    count_t=np.zeros(2019,dtype=int)
    for i in range(len(s)):
        count_t[int(s[i])]+=1
        for k in range(2019):
            t=(k*10+int(s[i]))%2019
            count_t[k]-=count[k]
            count_t[t]+=count[k]
            if t==0:
                ans+=count[k]
        #print(count[0:20])
        #print(count_t[0:20])
        count=count+count_t
        count_t-=count_t
    print(ans)
                
if __name__ == '__main__':
    do()

### FIXED CODE ###

INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    s=STR()
    cnt=[0]*2019
    cnt[0]=1
    temp=0
    keta=1
    ans=0
    for i in s[::-1]:
        temp=(temp+int(i)*keta)%2019
        keta=(keta*10)%2019
        cnt[temp]+=1
    for i in cnt:
        ans+=(i*(i-1))//2
    print(ans)
    
    
if __name__ == '__main__':
    do()
import numpy as np
from numpy.fft import rfft,irfft

p = 200003
N = int(input())
A = list(map(int,input().split()))
a = np.zeros(p-1)

g = 1
d = {}
p2 = [1]*p
for i in range(p):
    d[g] = i
    p2[i] = g
    g *= 2
    g %= p

for i in range(N):
    if A[i]==0:
        continue
    a[d[A[i]]] += 1

b = rfft(a,2*p-2)
b = irfft(b*b,2*p-2)
b = np.rint(b).astype(np.int64)

ans = 0
for i in range(p-1):
    ans += (b[i]+b[i+p-1])*p2[i]

for i in range(N):
    ans -= A[i]**2%p
ans //= 2
print(ans)

### FIXED CODE ###

import numpy as np
from numpy.fft import rfft,irfft

p = 200003
N = int(input())
A = list(map(int,input().split()))
a = np.zeros(p-1)

g = 1
d = {}
p2 = [1]*(p-1)
for i in range(p-1):
    d[g] = i
    p2[i] = g
    g *= 2
    g %= p

for i in range(N):
    if A[i]==0:
        continue
    a[d[A[i]]] += 1

b = rfft(a,2*p-2)
b = irfft(b*b,2*p-2)
b = np.rint(b).astype(np.int64)

ans = 0
for i in range(p-1):
    ans += (b[i]+b[i+p-1])*p2[i]

for i in range(N):
    ans -= A[i]**2%p
ans //= 2
print(ans)
n = int(input())
s, t = map(input().split())
ans = ""
for i, j in zip(s,t):
  ans += i
  ans += j
print(ans)

### FIXED CODE ###

n = int(input())
s, t = map(str, input().split())
ans = ""
for i, j in zip(s,t):
  ans += i
  ans += j
print(ans)
from sys import stdin, setrecursionlimit
from bisect import bisect_right


def main():
    input = stdin.buffer.readline
    n = int(input())
    a = list(map(int, input().split()))
    a.sort()

    idx = bisect_right(a, 0)

    if idx % 2 == 0:
        print(sum(a[idx:]) - sum(a[:idx]))
    else:
        print(sum(a[idx:]) - sum(a[:idx]) - 2 * min(-a[idx - 1], a[idx]))


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()


### FIXED CODE ###

from sys import stdin, setrecursionlimit
from bisect import bisect_right


def main():
    input = stdin.buffer.readline
    n = int(input())
    a = list(map(int, input().split()))
    a.sort()

    idx = bisect_right(a, 0)

    if idx % 2 == 0:
        print(sum(a[idx:]) - sum(a[:idx]))
    elif idx == n:
        print(a[idx - 1] - sum(a[:idx - 1]))
    else:
        print(sum(a[idx:]) - sum(a[:idx]) - 2 * min(-a[idx - 1], a[idx]))


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()
import sys
import collections
from functools import lru_cache

sys.setrecursionlimit(10 ** 5 + 1)
xy = []
d = collections.defaultdict(list)

@lru_cache(maxsize=10 ** 5 + 1)
def alg_memoization_recursion(f):
    mt = 0
    for v in d[f]:
        mt = max(mt, alg_memoization_recursion(v) + 1)
    return mt


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, m = list(map(int, readline().split()))
    for i in range(m):
        x, y = list(map(int, readline().split()))
        d[x-1] += [y-1]
    mt = 0
    for i in range(n):
        mt = max(mt, alg_memoization_recursion(i))
    print(mt)


if __name__ == '__main__':
    solve()


### FIXED CODE ###

import sys
import collections
from functools import lru_cache

xy = []
d = collections.defaultdict(list)
@lru_cache(maxsize=None)
def alg_memoization_recursion(f):
    mt = 0
    for v in d[f]:
        mt = max(mt, alg_memoization_recursion(v) + 1)
    return mt


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    sys.setrecursionlimit(10 ** 5 + 1)
    n, m = list(map(int, readline().split()))
    for i in range(m):
        x, y = list(map(int, readline().split()))
        d[x-1] += [y-1]
    mt = 0
    for i in range(n):
        mt = max(mt, alg_memoization_recursion(i))
    print(mt)


if __name__ == '__main__':
    solve()
N=int(input())
if N%2==0:
    print((N/2)/N) 
else if N==1:
    print(1.0)
else:
    print(((N/2)+1)/N)

### FIXED CODE ###

import math
N=int(input())
if N%2==0:
    print((N/2)/N) 
elif N==1:
    print(N/N)
else:
    round_number=math.ceil(N/2)
    print(round_number/N)
N = int(input())
a = [input() for i in range(N)]

for num in range(1, N):
  if a[num][-1] != a[num+1][0]:
    print('No')
    break
  if a[num] in a:
    print('No')
    break
  print('Yes')

### FIXED CODE ###

N = int(input())
a = [input() for i in range(N)]
 
for num in range(N):
  if num > 0:
    if a[num] in a[:num-1]:
    	print('No')
    	break
  if num < N-1:
    if a[num][-1] != a[num+1][0]:
    	print('No')
    	break
  if num == N-1:
    print('Yes')
n, q = map(int, input().split())
cn = list(map(int, input().split()))
s = [-1]*(n+1)
t = [0]*n
for i in range(n):
    j = cn[i]
    if s[j] == -1:
        t[i] = -1
        s[j] = i
    else:
        t[i] = s[j]
        s[j] = i

ans = [0]*q
for i in range(q):
    count = 0
    l, r = map(int, input().split())
    for j in range(l-1,r):
        if t[j] >= l-1:
            count += 1
    ans[i] = r-l+1-count

for i in ans:
    print(i)

### FIXED CODE ###

x = int(input())
if x >=30:
    print('Yes')
else:
    print('No')