Harryxun/stf_run huggingface dataset:
import math
n = int(input())
l = sorted(list(map(int,input().split())))
c = 0
b = {}
for i in range(len(l)):
    if l[i] in b:
        b[l[i]] += 1
    else:
        b[l[i]] = 1

for i in range(len(l) - 1, -1, -1):
    if  b[l[i]] == 0:
        continue
    t = l[i]
    b[l[i]] -= 1
    s = 2 ** math.floor(math.log2(temp))
    st = 2*s - t 
    if l == []:
        break
    if st in b and b[st] > 0:
        b[2 * s - t] -= 1
        c += 1
print(c)

### FIXED CODE ###

import math
n = int(input())
l = sorted(list(map(int,input().split())))
c = 0
b = {}
for i in range(len(l)):
    if l[i] in b:
        b[l[i]] += 1
    else:
        b[l[i]] = 1

for i in range(len(l) - 1, -1, -1):
    if  b[l[i]] == 0:
        continue
    t = l[i]
    b[l[i]] -= 1
    s = 2 ** math.floor(math.log2(t))
    st = 2*s - t 
    if l == []:
        break
    if st in b and b[st] > 0:
        b[2 * s - t] -= 1
        c += 1
print(c)
[N]=list(map(int, input().split()))
A=list(map(int, input().split()))
c=0
for i in range (0,N):
    B=sorted(A[0:i+1],reverse=True)
    if B[i] == A[i]:
        c=c+1
print(c)

### FIXED CODE ###

[M,N]=list(map(int, input().split()))
if M==N:
    print("Yes")
else:
    print("No")
n=int(input())

def count_attack(hp):
    count = 0
    if hp == 2 or hp == 3:
        return 3
    else:
        # calculate new hp
        count += 1
        hp_child = hp //2
        count += 2 * count_attack(hp_child)
        return count

print(count_attack(n))

### FIXED CODE ###

n=int(input())

def count_attack(hp):
    count = 0        
    if hp == 2 or hp == 3:
        return 3
    else:
        # calculate new hp
        count += 1
        hp_child = hp //2
        count += 2 * count_attack(hp_child)
        return count

if n == 1:
    print(1)
else:
    print(count_attack(n))
l = map(int, input())
 
a = 1
for i in l:
	a *= i
	if a > 1e18:
		a = -1
		break
print(a)

### FIXED CODE ###

A, B = map(int, input().split())
print(A * B)
import math,itertools,fractions,heapq,collections,re,bisect,sys,functools

sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
dy = [-1,0,1,0]
dx = [0,1,0,-1]
ddy = [-1,-1,0,1,1,1,0,-1]
ddx = [0,1,1,1,0,-1,-1,-1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

#######################################################################

x,y,z,k = LI()
A = sorted(LI(),reverse=True)
B = sorted(LI(),reverse=True)
C = sorted(LI(),reverse=True)

ab = []
for a in A:
    for b in B:
            ab.append(a+b)
ab.sort(reverse=True)
res = []
for i in range(k):
    for c in C:
        res.append(ab[i]+c)
res.sort(reverse=True)

for i in range(k):
    print(res[i])

### FIXED CODE ###

x,y,z,k = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
res = []
for p in range(x):
	for q in range(y):
		if (p+1)*(q+1) > k:
			break
		for r in range(z):
			if (p+1)*(q+1)*(r+1) > k:
				break
			res.append(A[p]+B[q]+C[r])
res.sort(reverse=True)
for i in res[:k]:
	print(i)
n = int(input())
cnt=0
for i in range(1,n+1):
    for j in range(1,n+1):
        for k in range(1,n+1):

            cnt += gcd(i,j,k)

print(cnt)

### FIXED CODE ###

import math

n = int(input())
cnt=0
for i in range(1,n+1):
    for j in range(1,n+1):
        t = math.gcd(i,j)
        for k in range(1,n+1):
            cnt +=  math.gcd(k,t)

print(cnt)
N, Y, A, B, C = map(int, input().split())

P = list(map(int, input().split()))
Q = list(map(int, input().split()))
R = list(map(int, input().split()))
        
P.sort(reverse=True)
Q.sort(reverse=True)
R.sort(reverse=True)

A=P[:X]+Q[:Y]+R

A.sort(reverse=True)

print(A[X+Y])

### FIXED CODE ###

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

P = list(map(int, input().split()))
Q = list(map(int, input().split()))
R = list(map(int, input().split()))
        
P.sort(reverse=True)
Q.sort(reverse=True)
R.sort(reverse=True)

A=P[:X]+Q[:Y]+R

A.sort(reverse=True)

print(sum(A[:X+Y]))
import sys
K = int(input())
N = 0
for i in range 2000000:
    if((K // (N + (10**i)*7)) == 0):
        print(i + 1)
        sys.exit()
    else:
        N = (N + (10**i)*7)
print(-1)

### FIXED CODE ###

K = int(input())

t = 7
for i in range(K):
    if t % K == 0:
        print(i + 1)
        break
    t = (t * 10 + 7) % K
else:
    print(-1)
#!python3

import sys
from functools import reduce
from operator import or_

iim = lambda: map(int, input().rstrip().split())

def resolve():
    N = int(input())
    S = list(input())
    Q = int(input())

    lo, hi = 0, N//2
    md = 1
    while lo < hi:
        md = (lo+hi) // 2
        if md**2 < N:
            lo = md + 1
        else:
            hi = md
    nn = md+1
    S1 = [None] * (nn+1)

    for i in range(N//nn):
        ii = i * nn
        S1[i] = set(S[j] for j in range(ii, min(N, ii+nn)))

    ans = []
    for cmd, i, j in (line.split() for line in sys.stdin):
        i = int(i) - 1
        if cmd == "1":
            ii = i // nn
            S[i] = j
            i2 = ii * nn
            S1[ii] = set(S[k] for k in range(i2, min(N, i2+nn)))
        elif cmd == "2":
            j = int(j)
            ia, ib = divmod(i, nn)
            ja, jb = divmod(j, nn)

            if ib > 0:
                ia += 1
            ss = set()
            ss = reduce(or_, (S1[i1] for i1 in range(ia, ja)), ss)

            if ib > 0:
                for i1 in range(i, i-ib+nn):
                    ss.add(S[i1])
            if jb > 0:
                for i1 in range(ja*nn, j):
                    ss.add(S[i1])

            ans.append(len(ss))

    print(*ans, sep="\n")

if __name__ == "__main__":
    resolve()


### FIXED CODE ###

#!python3

import sys

from bisect import bisect, insort_left

iim = lambda: map(int, input().rstrip().split())

def resolve():
    N = int(input())
    S = list(input())
    Q = int(input())

    c0 = ord('a')
    S1 = [[] for i in range(26)]
    for i, c1 in enumerate(S):
        ci = ord(c1) - c0
        S1[ci].append(i)

    ans = []
    for cmd, i, j in (line.split() for line in sys.stdin):
        i = int(i) - 1
        if cmd == "1":
            if S[i] == j:
                continue

            c1 = ord(S[i]) - c0
            s1 = S1[c1]
            s1.pop(bisect(s1, i)-1)
            S[i] = j
            c1 = ord(j) - c0
            insort_left(S1[c1], i)
        elif cmd == "2":
            j = int(j) - 1
            num = 0

            for s1 in S1:
                ls = len(s1)
                k = bisect(s1, i-1, 0, ls)

                if k == ls:
                    continue
                if i <= s1[k] <= j:
                    num += 1

            ans.append(num)

    print(*ans, sep="\n")

if __name__ == "__main__":
    resolve()
a,b,c=map(str,input().split())
if b=="+":
  print(int(a)+int(b))
else:
  print(int(a)-int(b))

### FIXED CODE ###

a,b,c=map(str,input().split())
if b=="+":
  print(int(a)+int(c))
else:
  print(int(a)-int(c))
a=int(input())
b=[int(input()) for i in range(a)]
b.sort()
c=sum(b)
d=0
if c%10!=0:
  print(c)
else:
  for i in range(a):
    if b[i]%!=0:
      d=c-b[i]
      print(d)
      break
  if d==c:
    print(0)

### FIXED CODE ###

a=int(input())
b=[int(input()) for i in range(a)]
b.sort()
c=sum(b)
d=0
if c%10!=0:
  print(c)
else:
  for i in range(a):
    if b[i]%10!=0:
      c=c-b[i]
      print(c)
      break
  if sum(b)==c:
    print(0)
n,l=map(int,input().split())
c=[]
for i range(n):
  c.append(input())
c.sort()
print(''.join(c))
  
    


### FIXED CODE ###

n,l=map(int,input().split())
c=[]
for i in range(n):
  c.append(input())
c.sort()
print("".join(c))
while True:
    words = input()
    if words == EOF:
        break
    words = words.lower()
    for i in [chr(i) for i in range(97,97+26)]:
        print('{0}:{1}'.format(i,words.count(i)))

### FIXED CODE ###

wordcount = ""
while True:
    try:
        words = input()
        wordcount = wordcount + words.lower()
    except:
        break    
for i in [chr(i) for i in range(97,97+26)]:
    print('{0} : {1}'.format(i,wordcount.count(i)))
N = input()
A = list(map(int, input().split()))
count = 0
for i, a in enumerate(A[:-1]):
  if a == i+1:
    count += 1
    A[i+1] = a
    
peint(count)

### FIXED CODE ###

N = int(input())
P = list(map(int, input().split()))
count = 0
for i, p in enumerate(P):
    if p == i+1 and i == N-1:
        count += 1
    elif p == i+1:
        count += 1
        P[i] = P[i+1]
        P[i+1] = p

print(count)
whether = input()
if whether == Sunny:
  print('Cloudy')
elif whether == Cloudy:
  print('Rainy')
elif:
  print(Sunny)

### FIXED CODE ###

whether = input()
if whether == 'Sunny':
    print('Cloudy')
elif whether == 'Cloudy':
    print('Rainy')
elif whether == 'Rainy':
    print('Sunny')
#E
n=int(input())
a=tuple(map(int,input().split()))
import fractions
lcm=a[0]
ans=1/a[0]
for i in range(1,n):
    lcm=lcm*a[i]//fractions.gcd(lcm,a[i])
    ans+=1/a[i]
num=10**9+7
print(int(ans*lcm)%num)

### FIXED CODE ###

#E
n=int(input())
a=tuple(map(int,input().split()))
import fractions
lcm=a[0]
b_sum=0
for i in range(1,n):
    lcm=lcm*a[i]//fractions.gcd(lcm,a[i])

num=10**9+7
for i in range(n):
    b_sum+=(lcm//a[i])

print(b_sum%num)
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = [int(input()) for _ in range(n)]
M = 998244353
s = sum(a)
assert s%2==1
l = s//2 + int(s%2==1)
# dp = [[0]*(s+1) for _ in range(n+1)]
dp = [0]*(s+1)
dp[0] = pow(2, n, M)
inv2 = pow(2, M-2, M)
for i in range(1,n+1):
    num = a[i-1]
    for j in range(s, -1, -1):
        if j>=num:
            dp[j] += dp[j-num]*inv2
            dp[j] %= M
# if s%2==0:
#     dp[s//2] //= 2
val = sum(dp[i] for i in range(l, s+1)) * 3
ans = (pow(3,n,M) - val)%M
print(ans%M)

### FIXED CODE ###

import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = [int(input()) for _ in range(n)]
M = 998244353
s = sum(a)
l = s//2 + int(s%2==1)
# dp = [[0]*(s+1) for _ in range(n+1)]
dp = [0]*(s+1)
dp2 = [0]*(s+1)
dp[0] = pow(2, n, M)
dp2[0] = 1
inv2 = pow(2, M-2, M)
for i in range(1,n+1):
    num = a[i-1]
    for j in range(s, -1, -1):
        if j>=num:
            dp[j] += dp[j-num]*inv2
            dp[j] %= M
            dp2[j] += dp2[j-num]
            dp2[j] %= M
val = sum(dp[i] for i in range(l, s+1)) * 3
if s%2==0:
    val -= dp2[s//2]*3
ans = (pow(3,n,M) - val)%M
print(ans%M)
a = int(input())
d = {
    25 : 'Christmas',
    24 : 'Christmas Eve Eve',
    23 : 'Christmas Eve Eve Eve'
}
print(d[a])

### FIXED CODE ###

a = int(input())
d = {
    25 : 'Christmas',
    24 : 'Christmas Eve',
    23 : 'Christmas Eve Eve',
    22 : 'Christmas Eve Eve Eve'
}
print(d[a])
s = input()
k = int(input())

index = 0
while s[index] == "1":
    index += 1
if k <= index:
    print('1')
else:
    print(s[index])


### FIXED CODE ###

s = input()
k = int(input())

index = 0
while s[index] == "1" and index < len(s) - 1:
    index += 1
if k <= index:
    print('1')
else:
    print(s[index])
fn main() {
    let v: Vec<i32> = read_vec();
    if v[0] == v[1] {
        println!("{}", v[2]);
    } else if v[1] == v[2] {
        println!("{}", v[0]);
    } else {
        println!("{}", v[1]);
    }
}

// ######################################################################## //

// 標準入力から一行を読み取り、指定の型に変換する関数
pub fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

// 標準入力から一行を読み取り、空白文字で分割し、各要素を指定の型に変換する関数
pub fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

// 標準入力からn行を読み取り、各行を空白文字で分割し、各要素を指定の型に変換する関数
pub fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

// 10進数での各桁の和
pub fn sum_dights(x: isize) -> isize {
    if x % 10 == 0 {
        return 0;
    }
    let m = x % 10;
    m + sum_dights((x - m) / 10)
}


### FIXED CODE ###

a, b, c = map(int, input().split())
if a == b:
    print(c)
elif b == c:
    print(a)
else:
    print(b)
a = int(input())
ar = list(map(int,input().split(" ")))
ar = sorted(ar,reverse=True)
A = 0
B = 0
j = 0
while True:
    if A != 0 and B != 0:
        break
    if j == a - 1:
        break
    if ar[j] == ar[j+1] and A == 0:
        A = ar[j]
        j += 1
    elif ar[j] == ar[j+1] and A != 0:
        B = ar[j]
        j += 1
    j += 1
    print(ar[j])
print(A * B)

### FIXED CODE ###

import collections
a = int(input())
ar = list(map(int,input().split(" ")))
br = collections.Counter(ar)
cr = []
for k,v in br.items():
    if v >= 4:
        cr.append(k)
        cr.append(k)
    elif v >= 2:
        cr.append(k)
cr = sorted(cr,reverse=True)
if len(cr) < 2:
    print(0)
else:
    print(cr[0] * cr[1])
x , y = map(int,input().split())
if x % 3 == 0 or y % 3 == 0 or (x+y) % 3 ==0:
    print("Possible")
else:
    print("Impossible")
remote@G465:~/abc/067$ vim b.py
remote@G465:~/abc/067$ cat b.py
N ,K = map(int,input().split())
L = list(map(int,input().split()))
L = sorted(L)[::-1]
ans = 0
for i in range(K):
    ans = ans + L[i]
print(ans)


### FIXED CODE ###


N ,K = map(int,input().split())
L = list(map(int,input().split()))
L = sorted(L)[::-1]
ans = 0
for i in range(K):
    ans = ans + L[i]
print(ans)
n, a, b = map(int, input().split())
x = map(int, input().split())

ans = 0
for i in range(1, x):
  ans += min(b, (x[i]-x[i-1]+a-1)//a*a)

print(ans)

### FIXED CODE ###

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

ans = 0
for i in range(1, len(x)):
  ans += min(b, (x[i]-x[i-1])*a)

print(ans)
s = input()
k = int(input())
m = 0
n = 0
j = 0
for i in range(len(s)):
    if s.count(s[0]) == len(s):
        print(len(s) * k // 2)
        exit()
    if len(s) <= j + 1:
        if s[0] == s[-1] and s[-1]==s[-2] and s[-1]==s[-3] and s[0]==s[1]:
            print(s[10000000000000000000000000])
        break
    if s[j] == s[j + 1]:
        if j == len(s) - 1:
            n += 1
        else:
            m += 1
        j += 1
    j += 1
print(m * k + n)


### FIXED CODE ###

s = input()
k = int(input())
m = 0
n = 0
j = 0
for i in range(len(s)):
    if s.count(s[0]) == len(s):
        print(len(s) * k // 2)
        exit()
    if len(s) <= j + 1:
        if s[0] == s[-1] == s[-2]== s[-3]== s[-4]== s[-5]== s[len(s)//3] \
                and s[0] == s[1] == s[2]== s[3]== s[4]== s[5]:
            n+=1
        break
    if s[j] == s[j + 1]:
        if j == len(s) - 1:
            n += 1
        else:
            m += 1
        j += 1
    j += 1
print(m * k + n*(k-1))
n=int(input())
a=map(int,input().split())
sums=0
for i in range(n):
  sums+=1/a[i]
print(1/sums)

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
sums=0
for i in range(n):
  sums+=1/a[i]
print(1/sums)
a,b,c,d = map(str, input().split())
s = 0
if a == '+':
  s = s + 1
else:
  s = s - 1

if b == '+':
  s = s + 1
else:
  s = s - 1

if c == '+':
  s = s + 1
else:
  s = s - 1

if d == '+':
  s = s + 1
else:
  s = s - 1

print(s)

### FIXED CODE ###

s = input()
pu = s.count('+')
mi = s.count('-')
print(pu-mi)
n, m = map(int, input().split())
lst = list(map(int, input().split()))
lst = sorted(lst, key = lambda x:-x)
dic = {1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}

s = set()
for i in lst:
    s.add(dic[i])
s = list(sorted(s))

dp = [0] * (n+1)
for i in range(0, n+2):
    max_a = 0
    for j in s:
        if i - j >= 0:
            a = dp[i-j] + 1
            if max_a < a:
                max_a = a
    dp[i] = max_a

def out(dp, dic, n, ans, ans_digit):
    if len(ans) == ans_digit-1:
        for i in lst:
            if n == dic[i]:
                return ans + str(i)
    else:
        for i in lst:
            if n - dic[i] >= 0:
                if dp[n] -1 == dp[n-dic[i]]:
                    ans += str(i)
                    next_n = n - dic[i]
                    break
        return out(dp, dic, next_n, ans, ans_digit)
    
print(out(dp, dic, n, '', dp[n]))

### FIXED CODE ###

n, m = map(int, input().split())
lst = list(map(int, input().split()))
lst = sorted(lst, key = lambda x:-x)
dic = {1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}

s = set()
for i in lst:
    s.add(dic[i])
s = list(sorted(s))

dp = [0] * (n+1)
for i in range(0, n+1):
    a = 0
    max_a = 0
    for j in s:
        if i-j < 0:
            pass
        elif i == j:
            a = 1
        elif i - j > 0 and dp[i-j] > 0:
            a = dp[i-j] + 1
        if max_a < a:
            max_a = a
    dp[i] = max_a

ans = ''
ans_digit = dp[n]
while len(ans) < ans_digit:
    if len(ans) == ans_digit-1:
        for i in lst:
            if n == dic[i]:
                ans += str(i)
                break
    else:
        for i in lst:
            if n - dic[i] >= 0:
                if dp[n] -1 == dp[n-dic[i]]:
                    ans += str(i)
                    n -= dic[i]
                    break
    
print(ans)
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y = int(input()), int(input())
print("{}".format(X+Y//2))

### FIXED CODE ###

#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y= map(int,input().split())
print("{}".format(X + Y // 2))
n,k=map(int,input().split())
h=list(map(int,input().split()))
def changemin(a,b):
    if a>b:
        a=b
        return a
    return a
dp=[]
dp.append(0)
for i in range(1,n):
    dp.append(1000000)
for m in range(1,n):
    for j in range(1,k+1):
        dp[m]=changemin(dp[m],dp[m-j]+abs(h[m]-h[m-j]))
print(dp[n-1])

### FIXED CODE ###

# educational DP contest A
n,k=map(int,input().split())
h=list(map(int,input().split()))
def changemin(a,b):
    if a>b:
        a=b
        return a
    return a
dp=[]
dp.append(0)
for i in range(1,n):
    dp.append(100000000000)
for m in range(n):
    for j in range(1,min(k+1,n-m)):
        dp[m+j]=changemin(dp[m+j],dp[m]+abs(h[m]-h[m+j]))
print(dp[n-1])
s = input()
A, B, C, K = [int(v) for v in s.split(" ")]

if K <= A:
  print(K)
elif K <= A + B:
  print(A)
elif K <= A + B + C:
  print(A - (K - A - B))

### FIXED CODE ###

S = input()
T = input()

if len(T) != len(S) + 1:
  print("Yes")
else:
  if T.startswith(S):
    print("Yes")
  else:
    print("No")
from itertools import accumulate
from collections import Counter
n = int(input())
T = []
for _ in range(n):
    T.append(int(input()))
T.sort()
print(sum(accumulate(T)))
dic = Counter(T)
ans = 1
mod = 10**9+7
for i in dic.values():
    for j in range(1,i+1):
        ans *= j
        ans %= mod
print(ans)

### FIXED CODE ###

x,y = map(int,input().split())
if y % 2 != 0:
    print("No")
    exit()
a = y//2-x
b = 2*x-y//2
if a >= 0 and b >= 0:
    print("Yes")
else:
    print("No")
import std.stdio;

void main() {
  int X, A;
  readf("%d %d", &X, &A);
  writeln(X < A ? 0 : 10);
}

### FIXED CODE ###

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

if X < A:
    print(0)
else:
    print(10)
import math
a = int(input())
s = 1
for i in range(a):
    t= int(input())
    s = (t*s)//gcd(t,s)
print(s)
    

### FIXED CODE ###


def gcd(x,y):
    if x==0:return y
    else:return gcd(y%x,x)
a = int(input())
s = 1
for i in range(a):
    t= int(input())
    s = (t*s)//gcd(t,s)
print(s)
def gcd(x, y):
	if x < y:
		x, y = y, x
	if y == 0:
		return x
	z = x % y
	return gcd(y, z) 
	
N=int(input())
prenum = 1
for i in range(N):
	T = int(input())
	lcm = (prenum / gcd(prenum, T)) * T
	prenum = lcm
print(int(lcm))

### FIXED CODE ###

def gcd(x, y):
	if x < y:
		x, y = y, x
	if y == 0:
		return x
	z = x % y
	return gcd(y, z) 
	
N=int(input())
prenum = 1
for i in range(N):
	T = int(input())
	lcm = prenum // gcd(prenum, T) * T
	prenum = lcm
print(lcm)
N = input()
A = list(input())
intA = [int(s) for s in A]
j = 1
c = 0
while j == 1 :
    for i in range(len(intA)):
        if(intA[i]%2==1):
            j = 0
        else:
            intA[i] = intA[i]//2
    c += 1
print(c)

### FIXED CODE ###

s = int(input())
i = 0
if(s//100==1):
    i = i + 1
    s = s - 100
if(s//10==1):
    i = i + 1
    s = s-10
if(s==1):
    i = i + 1
print(i)
print((n=int(input()))*-~n>>1)

### FIXED CODE ###

def acum(n):
    if n <= 1:
        return 1
    return n + acum(n - 1)
print(acum(int(input())))
N, K, S = map(int, input().split())

l = [S] + [0]*(K-1) + [S%10**9]*(N-K) #長さKで要素が全てSの列（条件満たすK通り）と長さNーKの適当な列で長さN列を生成

print(*l) #*lは標準出力時にはいれつの[]を出力しないため


### FIXED CODE ###

H= int(input())
W= int(input())
N= int(input())

import math

u = N/max(H,W)

print(math.ceil(u))
l = [a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z]
s = input()
for i in range(25):
  if s == l[i]:
    print(l[i+1])

### FIXED CODE ###

l = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
s = input()
for i in range(25):
  if s == l[i]:
    print(l[i+1])
N = int(input())
s = list(input())
a = []
for i in range(1, N - 1):
  a.append(len(list(set(s[0:i]) & set(s[i:]))))
print(max(a))

### FIXED CODE ###

N = int(input())
s = list(input())
a = []
for i in range(1, N):
  a.append(len(list(set(s[0:i]) & set(s[i:]))))
print(max(a))
import fractions
n,m=map(int,input().split())
s=list(str(input()))
t=list(str(input()))

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

l=lcm(n, m)
ans=[0]*(l+1)

for i in range(n):
    index=l//n*i+1

    if ans[index]==0:
        ans[index]=s[i]
#print(ans)
for i in range(m):
    index=l//m*i+1
    if ans[index]==0:
        ans[index]=t[i]
    else:
        if t[i]!=ans[index]:
            print(-1)
            exit()
#print(ans)
print(l)

### FIXED CODE ###

import fractions
n,m=map(int,input().split())
s=list(str(input()))
t=list(str(input()))

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

l=lcm(n, m)
index=fractions.gcd(n,m)
#print(indexn,indexm)
for i in range(index):
    #print(i)
    if s[n//index*i]!=t[m//index*i]:
        print(-1)
        break
else:
    print(l)
import sys
import numpy as np
from numba import njit
#from numba import njit

import math
n,k = map(int,input().split())
a = np.array(input().split(),np.int64)

@njit('i8,i8,i8[::1]',cache=True)
def solve():
    for i in range(k):
        new = np.zeros_like(a)
        for j in range(n):
            distance = j - a[j]
            if distance < 0:
                distance = 0
            last =  j + a[j]
            if last > n-1:
                last = n-1
            new[distance]+=1
            if last+1 < n:
                new[last+1]-=1
        a = np.cumsum(new)
        if np.all(a==n):
            break
    print(*a)

solve()

### FIXED CODE ###


import numpy as np
from numba import njit

import math

n,k = map(int,input().split())
a = np.array(input().split(),np.int64)

@njit
def solve(n,k,a):
    for i in range(k):
        new = np.zeros_like(a)
        for j in range(n):
            distance = j - a[j]
            if distance < 0:
                distance = 0
            last =  j + a[j]
            if last > n-1:
                last = n-1
            new[distance]+=1
            if last+1 < n:
                new[last+1]-=1
        a = np.cumsum(new)
        if np.all(a==n):
            break
    return a

a = solve(n,k,a)
print(" ".join(a.astype(str)))
N=int(input())
f=map(int,list(N))
if N%sum(f)==0:
  print('Yes')
else:
  print('No')


### FIXED CODE ###

N=int(input())
f=map(int,list(str(N)))
if N%sum(f)==0:
  print('Yes')
else:
  print('No')