Harryxun/stf_run huggingface dataset:
from sys import stdin

s = int(stdin.readline().rstrip())

sl = len(str(s))
cnt = 0

for i in range(sl - 3):
    for j in range(i + 3, sl):
        num = s % (10 ** (sl - i)) // (10 ** (sl - j - 1))
        if num % 2019 == 0 and num > 0:
            cnt += 1

print(cnt)

### FIXED CODE ###

from sys import stdin

s,w = [int(x) for x in stdin.readline().rstrip().split()]
print("safe" if s > w else "unsafe")
for i in range(3):
    a,b,c = map(int, raw_input().split())
    if a*a == b*b + c*c:
        print "YES"
    else:
        print "NO"


### FIXED CODE ###

n = int(raw_input())
for i in range(n):
    num = map(int, raw_input().split())
    num.sort(reverse=True)
    if num[0]**2 == num[1]**2 + num[2]**2:
        print "YES"
    else:
        print "NO"
n,q=map(int,input().split())

tree=[[] for _ in range(n)]

for _ in range(n-1):
    a,b=map(int,input().split())
    tree[a-1].append(b-1)
    tree[b-1].append(a-1)

point=[0]*n
for _ in range(q):
    q,x=map(int,input().split())
    point[q-1]+=x

result=[0]*n

def counter(chouten,count):
    global result,point,tree
    count+=point[chouten]
    result[chouten]=count

    #print(chouten,result)

    for item in tree[chouten]:
        if result[item]==0:
            counter(item,count)

counter(0,0)

result=map(str,result)
print(" ".join(result))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)

input=sys.stdin.readline

n,q=map(int,input().split())

tree=[[] for _ in range(n)]

for _ in range(n-1):
    a,b=map(int,input().split())
    tree[a-1].append(b-1)
    tree[b-1].append(a-1)

point=[0]*n
for _ in range(q):
    q,x=map(int,input().split())
    point[q-1]+=x

result=["no"]*n

def counter(chouten,count):
    global result,point,tree
    count+=point[chouten]
    result[chouten]=count

    #print(chouten,result)

    for item in tree[chouten]:
        if result[item]=="no":
            counter(item,count)

counter(0,0)

result=map(str,result)
print(" ".join(result))
n, x = map(int,input().split())
l = list(map(int, input().split()))
s = 0
count = 1
for i in L:
    s += i
    if s > x:
        break
    count += 1
print(count)

### FIXED CODE ###

n, x = map(int,input().split())
l = list(map(int, input().split()))
s = 0
count = 1
for i in l:
    s += i
    if s > x:
        break
    count += 1
print(count)
N=int(input())
a=list(map(int,input().split()))
box=[0]*N
for i in range(N, 0,-1):
    sm = 0
    for j in range(i, N+1, i):
        sm += box[j-1]
    print(i, sm)
    box[i-1] = (sm % 2) ^ a[i-1]
print(sum(box))
print(*sum)

### FIXED CODE ###

N = int(input())
a = [0]+list(map(int,input().split()))
ls = [0]*(N+1)
for i in range(N, 0, -1):
    sm = 0
    for j in range(i, N+1, i):
        sm += ls[j]
    ls[i] = (sm % 2) ^ a[i]
b = [i for i in range(N+1) if ls[i] == 1]
print(len(b))
print(*b)
import itertools
from functools import reduce
MOD = 10 ** 9 + 7
N, K = map(int, input().split())
A = [int(_) for _ in input().split()]
C = [list(i) for i in itertools.combinations(A, K)]
digits = [[] for i in range(len(C))]
for i, v in enumerate(C): 
  for j in v: 
    digits[i].append(len(str(abs(j))))
max_digits = max([reduce(lambda x, y: x+y, j) for j in digits])
res = [reduce(lambda x, y: x*y%MOD, j) for j in C]
res = [i for i in res if len(str(i)) <= max_digits]
ans = max(res)
if ans < 0:
  print(ans % MOD)
else:
  print(ans)

### FIXED CODE ###

n, k = map(int, input().split())
a = [int(i) for i in input().split()]
MOD = 10 ** 9 + 7
s, t = [], []  # 正、負の配列
for i in a:
  if i < 0:
    t.append(i)
  else:
    s.append(i)
S, T = len(s), len(t)
is_positive = False  # 積が正である
if S > 0:
  # 正の数が0より大きい
  if n == k:
    # nとkが同じ
    is_positive = (T % 2 == 0) # 負の数が偶数個のとき、積は正
  else:
    is_positive = True
else:
  is_positive = (k % 2 == 0)

ans = 1
if not is_positive:
  a.sort(key=abs)
  for i in range(k):
    ans = ans * a[i] % MOD
else:
  s.sort()
  t.sort(reverse=True)
  if k % 2 == 1:
    ans = ans * s.pop(-1) % MOD
  p = []
  while(len(s) >= 2):
    x = s.pop(-1)
    x *= s.pop(-1)
    p.append(x)
  while(len(t) >= 2):
    x = t.pop(-1)
    x *= t.pop(-1)
    p.append(x)
  p.sort(reverse=True)
  for i in range(k // 2):
    ans = ans * p[i] % MOD
print(ans)
N = int(input())
T = [int(input()) for _ in range(N)]

def gcd(A, B):
    A, B = sorted([A, B], reverse=True)
    r = A % B
    while r > 0:
        r = A % B
        A, B = B, r
    return max(B, 1)

tmp = (T[0] * T[1]) // gcd(T[0], T[1])
for t in T[2:]:
    tmp = (tmp * t) // gcd(tmp, t)

print(tmp)


### FIXED CODE ###

N = int(input())
T = [int(input()) for _ in range(N)]

def gcd(A, B):
    A, B = sorted([A, B], reverse=True)
    prev_r = B
    r = A % B
    while r > 0:
        prev_r = B
        r = A % B
        A, B = B, r
    return prev_r

if N > 1:
    tmp = (T[0] * T[1]) // gcd(T[0], T[1])
    for t in T[2:]:
        tmp = (tmp * t) // gcd(tmp, t)
else:
    tmp = T[0]

print(tmp)
a, b, c, d = map(int, input().split())
res = (a + b) - (c + d)

if res == 0:
  pritn("Balanced")
elif res > 0:
  print("Left")
else:
  print("Right")

### FIXED CODE ###

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

if res == 0:
  print("Balanced")
elif res > 0:
  print("Left")
else:
  print("Right")
S=input()
count=S.count("BW")
end=0
def sigma(i):
    a=[b for b in range(i+1)]
    return sum(a)
place=[]
i=0
while "BW" in S:
    i=S[i:].find("BW") + 1 + i
    place.append(i)
    S=S[:i-1]+S[i-1:].replace("BW","BB",1)
    print(S)

count=sum(place)-sigma(count-1)
print(count)

### FIXED CODE ###

S=input()
count=0
def sigma(i):
    a=[b for b in range(0,i+1)]
    return sum(a)
place=0
flag=0
start=0
for i in range(len(S)):
    if S[i]=="B":
        flag=1
    elif S[i]=="W":
        if flag == 1:
            count += 1
            place += i - start
        else:
            start+=1
ans=place-sigma(count-1)
print(ans)
n = int(input())
m = input().split()
m = [int(i) for i in m]
 
for i in range(n):
  l.append(0)
for i in m:
  ind = i-1
  l[ind] += 1
for i in l:
  print(i)

### FIXED CODE ###

n = int(input())
m = input().split()
m = [int(i) for i in m]
 
l =[]
for i in range(n):
  l.append(0)
for i in m:
  ind = i-1
  l[ind] += 1
for i in l:
  print(i)
N = int(input())
S = list(map(str, input().split()))
if 'Y' in S:
    print('Four')
else:
    print('Three')


### FIXED CODE ###

N = int(input())

print(N // 3)
S = list(map(int, input().split()))
A = list(map(int, input().split()))
U = int(input())

ind = S.index(U)

A[ind] -= 1

print("".join(A))


### FIXED CODE ###

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

ind = S.index(U)

A[ind] -= 1

print(" ".join(list(map(str, A))))
def slove():
    import sys
    input = sys.stdin.readline
    n, m = list(map(int, input().rstrip('\n').split()))
    x = list(map(int, input().rstrip('\n').split()))
    if n >= m:
        print(0)
    else:
        x.sort()
        y = []
        for i, v in enumerate(x):
            if i != 0:
                y.append([abs(v - x[i-1]), i, i-1])
        y = sorted(y, key=lambda x: x[0], reverse=True)
        cnt = 0
        z = [0, m-1]
        for i in range(n-1):
            z.append(y[i][1])
            z.append(y[i][2])
        z.sort()
        for i in range(1, m, 2):
            cnt += abs((x[z[i]] - x[z[i-1]]))
        print(cnt)


if __name__ == '__main__':
    slove()


### FIXED CODE ###

import heapq
n, m = map(int, input().split())
if n >= m:
    print(0)
else:
    x = list(map(int, input().split()))
    x.sort()
    d = []
    heapq.heapify(d)
    for i in range(1, m):
        heapq.heappush(d, [-abs(x[i] - x[i-1]), i, i - 1])
    total = 0
    a = [0, m - 1]
    for i in range(n-1):
        p = heapq.heappop(d)
        a.append(p[1])
        a.append(p[2])
    a.sort()
    total = 0
    for i in range(1, len(a), 2):
        total += abs(x[a[i]] - x[a[i-1]])
    print(total)
S = str(input())
s_len = len(S)
ans = [0 for _ in range(s_len)]

def L_checker(n):
    if n+1 == s_len:
        return s_len
    for i in range(n+1,s_len):
        if S[i]=='R':
            return i
    return s_len


def check1(n, r_count):
    if S[n]=='R':
        check1(n+1, r_count+1)
    else:
        next_r = L_checker(n)
        total = r_count+next_r-n
        if (total)%2==0:
            ans[n-1]=int((total)/2)
            ans[n]=int((total)/2)
        elif r_count%2==1:
            ans[n-1]=int((total)//2)+1
            ans[n]=int((total)//2)
        else:
            ans[n-1]=int((total)//2)
            ans[n]=int((total)//2)+1
        if next_r == s_len:
            print(*ans)
        else:
            check1(next_r,0)

check1(0,0)

### FIXED CODE ###

S = str(input())
s_len = len(S)
ans = [0 for _ in range(s_len)]
r_count = 0
l_count = 0
before = 0
switch = 'R'


for i in range(s_len):
    if S[i]==switch:
        if switch == 'R':
            r_count += 1
        else:
            l_count += 1
    else:
        if switch == 'L':
            switch = 'R'
            if (r_count+l_count)%2 == 0:
                ans[before] = (r_count+l_count)//2
                ans[before-1] = (r_count+l_count)//2
            elif r_count%2 == 0:
                ans[before] = (r_count+l_count)//2+1
                ans[before-1] = (r_count+l_count)//2
            else:
                ans[before] = (r_count+l_count)//2
                ans[before-1] = (r_count+l_count)//2+1
            r_count = 1
            l_count = 0
        else:
            switch = 'L'
            before = i
            l_count = 1


if (r_count+l_count)%2 == 0:
    ans[before] = (r_count+l_count)//2
    ans[before-1] = (r_count+l_count)//2
elif r_count%2 == 0:
    ans[before] = (r_count+l_count)//2+1
    ans[before-1] = (r_count+l_count)//2
else:
    ans[before] = (r_count+l_count)//2
    ans[before-1] = (r_count+l_count)//2+1

print(*ans)
N, u, v = (int(i) for i in input().split())
adj=[]
for i in range(N+1):adj.append([])
for i in range(N-1):
	a,b = map(int,input().split())
	adj[a]+=[b]
	adj[b]+=[a]
	
prof = [0]*(N+1)
haut = [0]*(N+1)
parent = [-1]*(N+1)

def enraciner(sommet):
	for s in adj[sommet]:
		if s!=parent[sommet]:
			parent[s] = sommet
			prof[s] = 1+prof[sommet]
			enraciner(s)
	haut[sommet] = 1
	tmp = [haut[s]for s in adj[sommet] if s!=parent[sommet]]
	if tmp: haut[sommet]+=max(tmp)

enraciner(v)

# ~ print("parent",parent)
# ~ print("haut",haut)
# ~ print("prof",prof)

ans = 0

#montee
pu = prof[u]
pv = prof[v]
m = (pu - pv -1)//2
pu-=m
pv+=m
# ~ print("m",m)
ans+=m
for i in range(m):
	u = parent[u]

mx = 0
# ~ if len(adj[u])>1:mx = max(haut[i] for i in adj[u] if i!= parent[u])
# ~ print("mx",mx)
ans+= mx

last = (pu-pv)//2
# ~ print("last",last)
ans+=last

print(ans)



### FIXED CODE ###

N, u, v = (int(i) for i in input().split())
adj=[]
for i in range(N+1):adj.append([])
for i in range(N-1):
	a,b = map(int,input().split())
	adj[a]+=[b]
	adj[b]+=[a]

def distances(sommet):
	d = [-1]*(N+1)
	File = [sommet]
	d[sommet] = 0
	while File:
		s = File.pop()
		for x in adj[s]:
			if d[x]==-1:
				d[x] = 1+d[s]
				File.append(x)
	return d


t = distances(u)
a = distances(v)

# ~ print(t)
# ~ print(a)

ans = -1
for i in range(1,N+1):
	if t[i]<a[i]:
		ans = max(ans, a[i]-1)
		
print(ans)
A = list(map(int,input().split))
A.sort()
print(A[2]-A[0])

### FIXED CODE ###

A = list(map(int,input().split()))
A.sort()
print(A[2]-A[0])
from functools import lru_cache
def head_prob(N,p):
    @lru_cache(None)
    def f(i,k):
        if i <0 or k <0: return 0
        if i == 0 and k == 1:
            return p[0]
        if i == 0 and k == 0:
            return 1 - p[0]
        return p[i]*f(i-1,k-1) + (1-p[i])*f(i-1,k)

    probs = [(f(N-1,k),k) for k in range(1,N+1)]
    return sum(prob[0] for prob in probs if prob[1] > N/2)



N = int(input())
p = list(map(float, input().split()))
print(head_prob(N,p))

### FIXED CODE ###

n = int(input())
p = list(map(float, input().split()))

dp = [0 for j in range(n + 1)]
dp[0] = 1
for i in range(n):
    pi = p[i]
    for j in range(i, -1, -1):
        dp[j + 1] = dp[j + 1] * pi + dp[j] * (1 - pi)
    dp[0] *= pi
print(sum(dp[:n // 2 + 1]))
X, Y = [int(item) for item in input().split()]

res = 0

if X == 1:
    res += 300_000
elif X == 2:
    res += 200_000
elif X == 3:
    res += 100_000

if Y == 1:
    res += 300_000
elif Y == 2:
    res += 200_000
elif Y == 3:
    res += 100_000

if X ==1 and Y == 1:
    res += 400_000

print(res)

### FIXED CODE ###

x, y = [int(item) for item in input().split()]

res = 0

if x == 1:
    res += 300000
elif x == 2:
    res += 200000
elif x == 3:
    res += 100000

if y == 1:
    res += 300000
elif y == 2:
    res += 200000
elif y == 3:
    res += 100000

if x == 1 and y == 1:
    res += 400000

print(res)
n,m=map(int,input().split())
a=[int(input()) for i in range(m)]
mod=10**9+7
dp=[0]*(n+1)
dp[0]=1
if a[0]==1:
  dp[1]=0
else:
  dp[1]=1
a=set(a)
for i in range(2,n+1):
  if i in a:
    dp[i]=0
  else:
    dp[i]=(dp[i-1]+dp[i-2])%mod
print(dp[n])

### FIXED CODE ###

n,m=map(int,input().split())
a=set()
for i in range(m):
  a.add(int(input()))
mod=10**9+7
dp=[0]*(n+1)
dp[0]=1
if 1 in a:
  dp[1]=0
else:
  dp[1]=1
if n==1:
  print(dp[1])
  exit()
if 2 in a:
  dp[2]=0
else:
  dp[2]=dp[1]+1
for i in range(3,n+1):
  if i in a:
    dp[i]=0
  else:
    dp[i]=(dp[i-1]+dp[i-2])%mod
print(dp[n])
import sys
sys.setrecursionlimit(100)
#print(sys.getrecursionlimit())
n,m=map(int,input().split())
dp=[-1]*n
E=[ [] for i in range(n) ]

for i in range(m):
  x,y=map(int,input().split())
  x-=1
  y-=1
  E[x].append(y)

def rec(v):
  if dp[v]!=-1:return dp[v]
  res=0
  for nv in E[v]:
    res=max(res,rec(nv)+1)
  dp[v]=res
  return res

res=0
for v in range(n):
  res=max(res,rec(v))
print(res)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**5)
#print(sys.getrecursionlimit())
n,m=map(int,input().split())
dp=[-1]*n
E=[ [] for i in range(n) ]

for i in range(m):
  x,y=map(int,input().split())
  x-=1
  y-=1
  E[x].append(y)

def rec(v):
  if dp[v]!=-1:return dp[v]
  res=0
  for nv in E[v]:
    res=max(res,rec(nv)+1)
  dp[v]=res
  return res

res=0
for v in range(n):
  res=max(res,rec(v))
print(res)
n = int(input())
a = list(map(int,input().split()))

a.sort()

u,d,z = 0,0,0
uu,dd = [],[]
for i in range(n):
    if a[i] > 0:
        u += 1
        uu.append(a[i])
    elif a[i] < 0:
        d += 1
        dd.append(a[i])
    else:
        z += 1
        
dd = dd[::-1]
        
ans = []
if d == 0:
    if z != 0:
        for i in range(z-1):
            ans.append((0,0))
        cur = 0
        for i in range(u-1):
            ans.append((cur,uu[i]))
            cur -= uu[i]
        ans.append((uu[u-1],cur))
        cur = uu[u-1] - cur
    else:
        cur = uu[0]
        for i in range(u-2):
            ans.append((cur,uu[i+1]))
            cur -= uu[i+1]
        ans.append((uu[u-1],cur))
        cur = uu[u-1] - cur
        
elif u == 0:
    if z != 0:
        for i in range(z-1):
            ans.append((0,0))
        cur = 0
        for i in range(d):
            ans.append((cur,dd[i]))
            cur -= dd[i]
    
    else:
        dd = d[::-1]
        cur = dd[0]
        for i in range(u-1):
            ans.append((cur,uu[i+1]))
            cur -= uu[i+1]
            
else:
    for i in range(z):
        ans.append((uu[0],0))
    cur1 = uu[0]
    cur2 = dd[0]
    for i in range(d-1):
        ans.append((cur1,dd[i+1]))
        cur1 -= dd[i+1]
    for i in range(u-1):
        ans.append((cur2,uu[i+1]))
        cur2 -= uu[i+1]
        
    ans.append((cur1,cur2))
    cur = cur1 - cur2
    
print(cur)
for i in ans:
    print(*i)

### FIXED CODE ###

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

a.sort()

u,d,z = 0,0,0
uu,dd = [],[]
for i in range(n):
    if a[i] > 0:
        u += 1
        uu.append(a[i])
    elif a[i] < 0:
        d += 1
        dd.append(a[i])
    else:
        z += 1
        
dd = dd[::-1]
        
ans = []
if u == 0 and d == 0:
    for i in range(z-1):
        ans.append((0,0))
    cur = 0
    
elif d == 0:
    if z != 0:
        for i in range(z-1):
            ans.append((0,0))
        cur = 0
        for i in range(u-1):
            ans.append((cur,uu[i]))
            cur -= uu[i]
        ans.append((uu[u-1],cur))
        cur = uu[u-1] - cur
    else:
        cur = uu[0]
        for i in range(u-2):
            ans.append((cur,uu[i+1]))
            cur -= uu[i+1]
        ans.append((uu[u-1],cur))
        cur = uu[u-1] - cur
        
elif u == 0:
    if z != 0:
        for i in range(z-1):
            ans.append((0,0))
        cur = 0
        for i in range(d):
            ans.append((cur,dd[i]))
            cur -= dd[i]
    
    else:
        cur = dd[0]
        for i in range(d-1):
            ans.append((cur,dd[i+1]))
            cur -= dd[i+1]
            
else:
    for i in range(z):
        ans.append((uu[0],0))
    cur1 = uu[0]
    cur2 = dd[0]
    for i in range(d-1):
        ans.append((cur1,dd[i+1]))
        cur1 -= dd[i+1]
    for i in range(u-1):
        ans.append((cur2,uu[i+1]))
        cur2 -= uu[i+1]
        
    ans.append((cur1,cur2))
    cur = cur1 - cur2
    
print(cur)
for i in ans:
    print(*i)
from math import gcd


def make_divisors(n):
    lower_divisors, upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]

k = int(input())
ans = {2: -1, 3: 1, 5: -1, 7: 1}
if k in ans:
    print(ans[k])
if k % 7 == 0:
    k //= 7

p = make_divisors(k-1)
for i in p:
    if int('7' * i) % p == 0:
        print(i)
         

### FIXED CODE ###

k = int(input())
if k % 2 == 0 or k % 5 == 0:
    print(-1)
    exit()

num = 7
for i in range(1,10**6):
    if num % k == 0:
        print(i)
        break
    num = (num % k) * 10 + 7
import re
X=sorted(re.findall("[ACGT]+",input()), key=len)
print(len(X[-1]))

### FIXED CODE ###

S = str(input())
m=0
point=0
for i in S:
    if i == "A" or i == "G" or i == "C" or i == "T":
        point+=1
    else:
        point*=0
    m = max(m, point)
print(m)
alpha = "abcdefghijklmnopqrstuvwxy"
C = input()
print(alpha[alpha.index(C)+1])


### FIXED CODE ###


alpha = "abcdefghijklmnopqrstuvwxyz"
C = input()
print(alpha[alpha.index(C)+1])
k = int(input())

def f(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])
    if arr==[]:
        arr.append([n, 1])
    return arr
u = f(k)

def yakusu(n):
    u = [n]
    i = 2
    while i <= n/2:
        if n%i == 0:
            u.append(i)
        i += 1
    return sorted(list(u))

v = yakusu(k-1)
del v[-1]

if k==1:
    print(1)
elif k%2==0 or len(u)>1:
    print(-1)
else:
    for i in v:
        if int('7'*i)%k==0:
            print(i)
            break
    else:
        print(k-1)

### FIXED CODE ###

x = int(input())

if x >= 30:
    print('Yes')
else:
    print('No')
n,m=map(int,input().split())
num=[0 for i in range(n)]
flag=[False for i in range(n)]
s=[]
c=[]
for i in range(m):
    si,ci=map(int,input().split())
    s.append(si)
    c.append(ci)

def ans():
    for i in range(m):
        if s[i]-1==0 and c[i]==0:
            continue
        if !flag[s[i]-1]:
            num[s[i]-1]=c[i]
            flag=True
        else:
            num[s[i]-1]=min(c[i],num[s[i]-1])
    if n!=1 and num[0]==0:
        print(-1)
        return
    for i in range(n):
        print(num[i],end="")
    print()

ans()

### FIXED CODE ###

def main():
    I=lambda:input()
    L=lambda:list(map(int,input().split()))
    n,m=L()
    sc=[]
    for i in range(m):
        si,ci=L()
        sc.append([si,ci])
    mini=0 if n==1 else 10**(n-1)
    for i in range(mini,10**n):
        tmp=str(i)
        flag=True
        for j in range(m):
            if tmp[sc[j][0]-1]!=str(sc[j][1]):
                flag=False
        if flag:
            print(i)
            exit()
    print(-1)
        
    
    
if __name__ == '__main__':
    main()
import math
A, B, C, D = map(int, input().split())
def div_num(a, b, c):
    if (a%c)==0:
        return (b//c)-(a//c)+1
    else:
        return (b//c)-(a//c)

XC = div_num(A, B, C)
XD = div_num(A, B, D)
XCD = div_num(A,B,int((C*D)/math.gcd(C,D)))
print(B-A+1-(XC+XD-XCD))

### FIXED CODE ###

A, B, C, D = map(int, input().split())
def div_num(a, b, c):
    if (a%c)==0:
        return (b//c)-(a//c)+1
    else:
        return (b//c)-(a//c)
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a
XC = div_num(A, B, C)
XD = div_num(A, B, D)
XCD = div_num(A,B,int((C*D)/gcd(C,D)))
print(B-A+1-(XC+XD-XCD))
S, T = map(str, input().split())
print(T + S).split('')


### FIXED CODE ###

S, T = input().split()
print(T + S)
from scipy.special import comb
from collections import Counter

N = int(input())
A = list(map(int, input().split()))
C = Counter(A)
x = 0

for c in C.values():
    x += comb(c, 2, exact=True)

for i in range(N):
    y = x - comb(C[A[i]], 2, exact=True) + comb(C[A[i]] - 1, 2, exact=True)
    print(y)


### FIXED CODE ###

from scipy.special import comb
from collections import Counter

N = int(input())
A = list(map(int, input().split()))
C = Counter(A)
x = 0

for c in C.values():
    x += comb(c, 2, exact=True)

for i in range(N):
    y = x - comb(C[A[i]], 2, exact=True) + comb(C[A[i]] - 1, 2, exact=True)
    print(y)
hw=input().split()
h=int(hw[0])
w=int(hw[1])
mx=[1,1,0,-1,-1,-1,0,1]
my=[0,1,1,1,0,-1,-1,-1]
grid=[]
for t in range(h):
	row=list(input())
	grid.append(row)
for i in range(w):
	for j in range(h):
		if grid[j][i]==".":
			ctr=0
			for k in range(8):
				adx=i+mx[k]
				ady=j+my[k]
				if adx>=0 and adx<w and ady>=0 and ady<h:
					if grid[ady][adx]=="#":
						ctr+=1
			grid[j][i]=ctr
for l in range(h):
    print(''.join(grid[l]))

### FIXED CODE ###

hw=input().split()
h=int(hw[0])
w=int(hw[1])
mx=[1,1,0,-1,-1,-1,0,1]
my=[0,1,1,1,0,-1,-1,-1]
grid=[]
for t in range(h):
	row=list(input())
	grid.append(row)
for i in range(w):
	for j in range(h):
		if grid[j][i]==".":
			ctr=0
			for k in range(8):
				adx=i+mx[k]
				ady=j+my[k]
				if adx>=0 and adx<w and ady>=0 and ady<h:
					if grid[ady][adx]=="#":
						ctr+=1
			grid[j][i]=str(ctr)
for l in range(h):
    print(''.join(grid[l]))
N = int(input())
S = input()
count = 0
for i in range(N):
    if S[i] == "A":
        if S[i+1] == "B":
            if S[i+2] == "C":
                count += 1
print(count)


### FIXED CODE ###

N = int(input())
S = input()
count = 0
for i in range(N - 2):
    if S[i] == "A":
        if S[i+1] == "B":
            if S[i+2] == "C":
                count += 1
print(count)
n = int(input())

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

count = [0] * (10**5)

for i in lis:
    count[i] += 1

t1 = 0
t2 = 0
  
for i in range(len(count)):
    if count[i] >= 2 and i+1 > t1:
        t2 = t1
        t1 = i

if count[t1] >= 4:
    a1 = t1*t1
    print(a1)
    exit()

print(t1*t2)



### FIXED CODE ###

from collections import Counter

n = int(input())

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

a = Counter(lis)

slis = sorted(set(lis))

t1 = 0
t2 = 0

for k, v in a.items():
    if v >=2 and k > t1:
        t2 = t1
        t1 = k

if a[t1] >= 4:
    print(t1*t1)
    exit()

print(t1*t2)
# A
A, B, C = map(int,input().split())
print(C+" "+B+" "+A)

### FIXED CODE ###

# A
A, B, C = map(int,input().split())
print(C, A, B)
d,t,s=input().split()
x=d/s
if x<=t:
  print("Yes")
else:
  print("No)


### FIXED CODE ###

d,t,s=map(int,input().split())
x=d/s
if x<=t:
  print("Yes")
else:
  print("No")