Harryxun/stf_run huggingface dataset:
import sympy
n = int(input())
cnt = 0
for i in range(1, n):
    cnt+=len(sympy.divisors(n-i))
print(cnt)


### FIXED CODE ###

n=int(input())
cnt=0
for a in range(1,n):
    cnt+=(n-1)//a

print(cnt)
import sys
s=input()
t=input()
n=len(s)-1
d=dict()
for i in range(n):
  if t[i] in d.keys():
  	if d[t[i]] != s[i]:
      print("No")
      sys.exit()
  else:
    d[t[i]] = s[i]
else:
  print("Yes")

### FIXED CODE ###

import sys
s=input()
t=input()
n=len(s)
d=dict()
d2=dict()
for i in range(n):
    if t[i] in d.keys():
        if d[t[i]] != s[i]:
            print("No")
            sys.exit()
    else:
        d[t[i]] = s[i]
    
    if s[i] in d2.keys():
        if d2[s[i]] != t[i]:
            print("No")
            sys.exit()
    else:
        d2[s[i]] = t[i]
else:
    print("Yes")
import math

a,b,c= map(int, input().split())
a1 =double(math.sqrt(a))
b1 =double(math.sqrt(b))
c1 =double(math.sqrt(c))

if a1+ b1 <c1:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

a,b,c=map(int,input().split())
if 4*a*b<(c-a-b)**2 and c-a-b>0:
    print('Yes')
else:
    print('No')
from math import log2
n, k = map(int, input().split())
a = list(map(int, input().split()))
m = max(a)
r = int(log2(m))
rank = [0]*(r+1)
for y in a:
    tmp = y
    for j in range(r, -1, -1):
        if tmp >= 2**j:
            rank[j] += 1
            tmp -= 2**j

y = 0
if k >= 2**(r+1):
    for i in range(int(log2(k)), r, -1):
        if y > k:
            break
        else:
            y += 2**i
    ans1 = ans2 = y
else
    ans1 = ans2 = 0
x1 = 0
for i in range(r, -1, -1):
    if rank[i] <= n//2:
        if x1 + 2**i > k:
            break
        else:
            x1 += 2**i
            ans1 += 2**i*(n-rank[i])
    else:
        ans1 += 2**i*rank[i]

x2 = 0
for i in range(r, -1, -1):
    if rank[i] <= n//2:
        if x2 + 2**i > k:
            break
        else:
            x2 += 2**i
            ans2 += 2**i*(n-rank[i])
    else:
        ans2 += 2**i*rank[i]

ans = max(ans1, ans2)



### FIXED CODE ###

n, k = map(int, input().split())
a = list(map(int, input().split()))
h = [[0, 0] for _ in range(41)]
b = list(map(int, bin(k)[2:].zfill(41)))
for i in a:
    for x, y in enumerate(map(int, bin(i)[2:].zfill(41))):
        h[x][y] += 1

ans = 0
ctr = 0
hm = [max(x, y)*2**(40-i) for i, [x, y] in enumerate(h)]
for i, v in enumerate(b):
    if not v:
        ctr += h[i][1]*2**(40-i)
    else:
        ans = max(ans, ctr+h[i][1]*2**(40-i)+sum(hm[i+1:]))
        ctr += h[i][0]*2**(40-i)
print(max(ans, ctr))
s=str(input())
if(s=="ABC"):
  print("ARC")
 else:
  print("ABC")

### FIXED CODE ###

s=str(input())
if(s=="ABC"):
  print("ARC")
else:
  print("ABC")
x=list(input().split())
x1=int(x[0])
y1=int(x[1])
x2=int(x[2])
if x2-x1==x3-x2:
  print('YES')
else:
  print('NO')

### FIXED CODE ###

x=list(input().split())
x1=int(x[0])
x2=int(x[1])
x3=int(x[2])
if (x2-x1)==(x3-x2):
  print('YES')
else:
  print('NO')
s, w = int(input().split())

if s<=w:
  print('unsafe')
else:
  print('safe')

### FIXED CODE ###

s, w = map(int, input().split())
 
if s<=w:
  print('unsafe')
else:
  print('safe')
n=int(input())
sp=0
A=list(map(int,input.split()))
for i in range(n):
  if i+1!=A[i]:
    sp+=1
if sp==0 or 2:
  print("YES")
  exit()
print("NO")


### FIXED CODE ###

n=int(input())
sp=0
A=list(map(int,input().split()))
for i in range(n):
  if i+1!=A[i]:
    sp+=1
if sp==0 or sp==2:
  print("YES")
  exit()
print("NO")
n,k,q=map(int,input().split())
a=[int(input()) for i in range(q)]
p=[k-q]*n
for i in range(q):
   #q回の正解が出る
    r=a[i]
    p[r]=p[r]+1
for i in range(n):
    if p[i]>0:
        print('Yes')
    else:
        print('No')

### FIXED CODE ###

n,k,q=map(int,input().split())
a=[int(input()) for i in range(q)]
p=[k-q]*n
for i in range(q):
   #q回の正解が出る
    r=a[i]-1
    p[r]=p[r]+1
    #正解したら１点多くなる
for i in range(n):
    if p[i]>0:
        print('Yes')
    else:
        print('No')
print input()**3

### FIXED CODE ###

x=int(input())
print(x**3)
import sys
input = sys.stdin.readline
import numpy as np
from scipy.sparse.csgraph import connected_components
from scipy.sparse import csr_matrix

N, M, K  = (int(i) for i in input().split())
graph = np.zeros((N+1, N+1))
graph2 = [[0] * (N+1) for i in range(N+1)]

#ABC = [[int(i) for i in input().split()] for i in range(N)]
for i in range(M):
    A, B =  (int(i) for i in input().split())
    graph[A][B] = 1
    graph[B][A] = 1
    graph2[A][B] = 1
    graph2[B][A] = 1

for j in range(K):
    A, B =  (int(i) for i in input().split())
    graph2[A][B] = -1
    graph2[B][A] = -1

#graph = np.array(graph)
#print(graph)
print(graph2)
n, labels = connected_components(graph)
size = [0]*n
for i in range(1, n):
    size[i] = np.count_nonzero(labels == i)
print(n)
# 2
print(labels)
print(size)
for i in range(1, N+1):
    count = 0
    for j in range(1, N+1):
        if labels[j] == labels[i] and graph2[i][j] != 0:
            count += 1
    print(size[labels[i]]-count-1)


### FIXED CODE ###

import sys
input = sys.stdin.readline

class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * (n+1)

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]
    
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return 
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

N, M, K  = (int(i) for i in input().split())

#graph = np.zeros((N+1, N+1))
#graph2 = [[0] * (N+1) for i in range(N+1)]
uf = UnionFind(N)
fblist = [0] * (N+1)

for i in range(M):
    A, B =  (int(i) for i in input().split())
    uf.union(A, B)
    fblist[A] += 1
    fblist[B] += 1
 
for j in range(K):
    A, B =  (int(i) for i in input().split())
    if uf.same(A, B):
        fblist[A] += 1
        fblist[B] += 1

for i in range(1, N+1):
    print(uf.size(i) - fblist[i] - 1, end=" ")

print()
import numpy as np


def func(x):
    if x == '.':
        return 2000
    else:
        return 0


H, W = map(int, input().split())
b = []
for _ in range(W):
    b.append(list(map(func, input())))
a = np.array(b)

for i in range(H - 1):
    a[1+i:, :] = np.minimum(a[1+i:, :], a[i:-1, :] + 1)
for i in range(H - 1):
    a[:-1-i, :] = np.minimum(a[:-1-i, :], a[1:H-i, :] + 1)
for j in range(W - 1):
    a[:, 1+j:] = np.minimum(a[:, 1+j:], a[:, j:-1] + 1)
for j in range(W - 1):
    a[:, :-1-j] = np.minimum(a[:, :-1-j], a[:, 1:W-j] + 1)

print(max(a))

### FIXED CODE ###

from collections import deque

H, W = map(int, input().split())
a = [[0] * W for _ in range(H)]
q = deque([])
for i in range(H):
    s = input()
    for j in range(W):
        if s[j] == '#':
            a[i][j] = 1
            q.appendleft((i, j, 0))

while True:
    try:
        i, j, val = q.pop()
        if i > 0 and a[i - 1][j] == 0:
            q.appendleft((i - 1, j, val + 1))
            a[i - 1][j] = 1
        if i < H - 1 and a[i + 1][j] == 0:
            q.appendleft((i + 1, j, val + 1))
            a[i + 1][j] = 1
        if j > 0 and a[i][j - 1] == 0:
            q.appendleft((i, j - 1, val + 1))
            a[i][j - 1] = 1
        if j < W - 1 and a[i][j + 1] == 0:
            q.appendleft((i, j + 1, val + 1))
            a[i][j + 1] = 1
    except:
        print(val)
        break
n = list(map(long, input().split())
count = 0
         
while count == n[2]:
	if n[0] > 0:
    	n[0]-=1   
        count+=1
    elif n[1] > 0:
        n[1]-=1
        count+=1
    else:
        break
 
print(n[0] n[1])

### FIXED CODE ###

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

if A > K:
  print(A - K, B)
elif B - (K - A) > 0:
  print(0, B - (K - A))
else:
  print(0,0)
from math import gcd
n =int(input())
a =list(map(int ,input().split()))

b =[a[0]]
for i in range(1,n-1):
    b.append(gcd(b[-1],a[i]))

c =[a[-1]]
for i in range(n-2,0,-1):
    c.append(gcd(c[-1], a[i]))

MAX =0
for i in range(n):
    if i == 0:
        MAX =max(MAX, c[-1])
    elif i ==n-1:
        MAX =max(MAX, b[-1])
    else:
        MAX =max(MAX, gcd(b[i-1], c[n-i-2]))

print(MAX)

### FIXED CODE ###

from fractions import gcd
n =int(input())
a =list(map(int ,input().split()))

b =[a[0]]
for i in range(1,n-1):
    b.append(gcd(b[-1],a[i]))

c =[a[-1]]
for i in range(n-2,0,-1):
    c.append(gcd(c[-1], a[i]))

MAX =0
for i in range(n):
    if i == 0:
        MAX =max(MAX, c[-1])
    elif i ==n-1:
        MAX =max(MAX, b[-1])
    else:
        MAX =max(MAX, gcd(b[i-1], c[n-i-2]))
print(MAX)
S == input()
if S == "ABC" 
	print("ARC")
else:
  	print("ABC")

### FIXED CODE ###

S = input()
if S == "ABC":
	print("ARC")
else:
  	print("ABC")
import itertools

def read():
    N = str(input().strip())
    K = int(input().strip())
    return N, K

def nCk(n, k):
    return len(list(itertools.combinations(range(n), k)))

def count_nonzero(L, H, K):
    """
    [0-H][0-9]{L-1}にマッチするL桁の数字から、非ゼロがK個のものを数え上げ
    L: 桁数
    H: 上位1桁目の数字
    K: 範囲内に含まれるゼロでない数字の数
    """
    count = 0
    factor = [1, 9, 81, 729]
    count += nCk(L-1, K) * factor[K]
    for h in range(1, H+1):
        count += nCk(L-1, K-1) * factor[K-1]
    return count



def solve(N, K):
    L = len(N)
    intN = [int(N[i]) for i in range(L)]
    count = 0
    # 最上位桁が[0-(intN[0]-1)]のものをカウント
    if K >= 1:
        count += count_nonzero(L, intN[0]-1, K)
    # 最上位桁がintN[0]、2桁目が[0-(intN[1]-1)]のものをカウント
    if K >= 2:
        count += count_nonzero(L-1, intN[1]-1, K-1)
    # 上位桁がintN[0]intN[1]、3桁目が[0-(intN[2]-1)]のものをカウント
    if K >= 3:
        count += count_nonzero(L-2, intN[2]-1, K-2)
    # 上位桁がintN[0]intN[1]intN[2]のものをカウント (自分自身)
    count += 1
    return count


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))


### FIXED CODE ###

import itertools

def read():
    N = str(input().strip())
    K = int(input().strip())
    return N, K

def solve(N, K):
    L = len(N)
    D = [int(N[i]) for i in range(L)]
    dp0 = [[0 for k in range(K+1)] for i in range(L+1)]
    dp1 = [[0 for k in range(K+1)] for i in range(L+1)]
    
    dp0[0][0] = 1
    for i in range(L):
        for k in range(K+1):
            if k < K and D[i] > 0:
                dp0[i+1][k+1] += dp0[i][k]
                for d in range(1, D[i]):
                    dp1[i+1][k+1] += dp0[i][k]
            if D[i] == 0:
                dp0[i+1][k] += dp0[i][k]
            else:
                dp1[i+1][k] += dp0[i][k]
            if k < K:
                for d in range(1, 10):
                    dp1[i+1][k+1] += dp1[i][k]
            dp1[i+1][k] += dp1[i][k]
    return dp0[L][K] + dp1[L][K]


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))
a,p = map(int,input().split())
 print(int((a*3+p)//2))

### FIXED CODE ###

a,p = map(int,input().split())
print((a*3+p)//2)
day = list(input().split('/'))
day[0] = '2018'
print(day[0],day[1],day[2],sep(/))

### FIXED CODE ###

print(input().replace('017','018'))
# -*- coding: utf-8 -*-
s = str(input())
t = str(input())

slen = len(s)
tlen = len(t)

if slen != tlen:
    print('No')
    break

for i in range(slen):
    if s == t:
        print("Yes")
        break
    s = s[-1] + s[:-1]


### FIXED CODE ###

# -*- coding: utf-8 -*-
s = str(input())
t = str(input())

slen = len(s)
tlen = len(t)

if slen != tlen:
    print("No")

for i in range(slen):
    if s == t:
        print("Yes")
        break
    s = s[-1] + s[:-1]

if s != t:
    print("No")
# coding: utf-8
import numpy as np


def solve(*args: str) -> str:
    n, m = map(int, args[0].split())

    keys = list(zip(
        list(map(lambda _: int(_.split()[0]), args[1::2])),
        map(
            lambda _: set2bin(
                set(map(int, _.split())),
                n, start=1, initial=False
            ), args[2::2])
    ))
    dp = DP()

    return str(
        dp.search_min_cost(
            keys, np.array([False for _ in range(n)], dtype=bool)
        )
    )


class DP:
    def __init__(self):
        self.cache = {}

    def search_min_cost(self, keys: list, unlocked: list) -> int:
        ret = 0
        args = '{},{}'.format(len(keys), bin2int(unlocked))

        if args in self.cache.keys():
            ret = self.cache[args]

        elif len(keys) == 0:
            if not all(unlocked):
                ret = -1

        else:
            a, C = keys[0]
            take = self.search_min_cost(keys[1:], C | unlocked)
            skip = self.search_min_cost(keys[1:], unlocked)

            if take == -1 and skip == -1:
                ret = -1
            elif take == -1:
                ret = skip
            elif skip == -1:
                ret = a + take
            else:
                ret = min(a+take, skip)

        self.cache[args] = ret
        return ret


def set2bin(S: set, n: int, start: int = 0, initial: bool = True) -> list:
    ret = np.array([initial for _ in range(n)], dtype=bool)
    for s in S:
        ret[s-start] = not initial
    return ret


def bin2int(B: list) -> int:
    ret = 0
    for n in range(len(B)):
        if B[n]:
            ret += 2**n

    return ret


if __name__ == "__main__":
    nm = input()
    _, m = map(int, nm.split())
    print(solve(*([nm]+[input() for _ in range(2*m)])))


### FIXED CODE ###

# coding: utf-8
from functools import reduce


def solve(*args: str) -> str:
    a_max = 1+12*10**5
    n, m = map(int, args[0].split())
    cache = {}

    for i in range(1, 1+2*m, 2):
        a, _ = map(int, args[i].split())
        c = reduce(
            lambda x, y: x | 1 << y-1,
            [0] + list(map(int, args[i+1].split()))
        )
        cache[c] = min(cache.get(c, a_max), a)

    for C in tuple(cache.items()):
        unlocked, cost = C
        for E in tuple(cache.items()):
            c, a = E
            cache[unlocked | c] = min(
                cache.get(unlocked | c, a_max),
                a + cost
            )

    return str(cache.get(2**n-1, -1))


if __name__ == "__main__":
    nm = input()
    _, m = map(int, nm.split())
    print(solve(*([nm]+[input() for _ in range(2*m)])))
H, W = map(int, input().split())

li = []
for i in range(H+2):
    li.append(["."]*(W+2))

for h in range(H):
    for w in range(W):
        li[h+1][w+1] = input()

S = [i[1:-1] for i in li][1:-1]

import numpy as np
ans = np.zeros([H+2, W+2], dtype=int)

for h in range(1, H+1):
    for w in range(1, W+1):
        if li[h][w]=="#":
            ans[h-1:h+2, w-1:w+2] += 1      

ans = ans.astype("str")
ans = ans[1:-1, 1:-1]

for h in range(H):
    for w in range(W):
        if S[h][w]=="#":
            ans[h, w] = "#"

for i in ans:
    print("".join(i))

### FIXED CODE ###

import numpy as np

# 読み込み
H, W = map(int, input().split())
S = []
for i in range(H):
    S.append(list(map(str, input().rstrip())))

# 外枠を「.」で囲う準備
li = []
for i in range(H+2):
    li.append(["."]*(W+2))

# 外枠付きSの生成
for i in range(1, H+1):
    li[i][1:-1] = S[i-1]

# カウント用配列の準備
ans = []
for i in range(H+2):
    ans.append([0]*(W+2))
ans = np.array(ans)

# カウント処理
for h in range(1, H+1):
    for w in range(1, W+1):
        if li[h][w]=="#":
            ans[h-1:h+2, w-1:w+2] += 1

# カウント結果から必要な場所だけ切り出す
ans = ans.astype("str")
ans = ans[1:-1, 1:-1]

# 「#」で上書きしながら出力
for h in range(H):
    for w in range(W):
        if S[h][w]=="#":
            ans[h, w] = "#"
    print("".join(ans[h]))
N = int(input())
A = list(map(int, input().split()))
Q = int(input())

num = []

for i in range(1, 100000):
	num.append(A.count(i))

S = sum(A)
slist = []

for i in range(Q):
	B, C = map(int, input().split())
	numb = num[B-1]
	S += (C - B) * numb
	num[C-1] += numb
	num[B-1] = 0
	slist.append(S)

[print(i) for i in slist]

### FIXED CODE ###

import collections

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

num = collections.Counter(A)

S = sum(A)
slist = []

for i in range(Q):
	B, C = map(int, input().split())
	numb = num[B]
	S += (C - B) * numb
	num[C] += numb
	num[B] = 0
	slist.append(S)

[print(i) for i in slist]
N,K = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
lm = []
lp = []
while l:
    x = l.pop(0)
    if x >= 0:
        lp.append(x)
    else:
        lm.append(-x)
ans = 100000000000
if lm and lp:
  for i in range(min(len(lp),K)):
    ans = min(ans,2*lp[i] + lm[-(K-i-1)],lp[i] + 2*lm[-(K-i-1)])
elif lp:
  ans = lp[K-1]
else:
  ans = lm[1-K]
print(ans)

### FIXED CODE ###

N,K = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
ans = 100000000000
for i in range(N-K+1):
  le = l[i]
  ri = l[i+K-1]
  ans = min(ans,abs(le)+abs(ri-le),abs(ri)+abs(ri-le))
print(ans)
from collections import deque
H,W=map(int,input().split())
L=[]
cnt=0
for i in range(H+2):
    if i==0 or i==H+1:
        S="#"*(W+2)
    else:
        S=input()
        S="#"+S+"#"
    L1=[]
    for j in range(W+2):
        if S[j]==".":
            cnt+=1
        L1.append(S[j])
    L.append(L1)
L[1][1]=0
D=deque()
D.append([1,1])
h=[0,1,0,-1]
w=[1,0,-1,0]
i=0
for i in range(10000):
    #print(D)
    #print(L)
    if D==[]:
        print(-1)
    elif D[0][0]==H and D[0][1]==W:
        print(cnt-L[H][W]-1)
        exit()
    for k in range(3):
        if L[D[0][0]+h[k]][D[0][1]+w[k]]==".":
            if [D[0][0]+h[k],D[0][1]+w[k]] not in D:
                D.append([D[0][0]+h[k],D[0][1]+w[k]])
            L[D[0][0]+h[k]][D[0][1]+w[k]]=L[D[0][0]][D[0][1]]+1
            
        elif L[D[0][0]+h[k]][D[0][1]+w[k]]=="#":
            pass
        else:
            if L[D[0][0]+h[k]][D[0][1]+w[k]]>L[D[0][0]][D[0][1]]+1:
                L[D[0][0]+h[k]][D[0][1]+w[k]]=L[D[0][0]][D[0][1]]+1
    D.popleft()

### FIXED CODE ###

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

A=[]
a=["#"]*(W+2)
A.append(a)
for i in range(H):
    s=input()
    s="#"+s+"#"
    A.append(list(s))
A.append(a)
#幅優先探索
#print(A)
P=[[1,1]]
A[1][1]=1
x=[1,-1,0,0]
y=[0,0,1,-1]
while P!=[]:
    #print(P)
    for j in range(4):
        if A[P[0][0]+x[j]][P[0][1]+y[j]]=="#":
            pass
        elif A[P[0][0]+x[j]][P[0][1]+y[j]]==".":
            A[P[0][0]+x[j]][P[0][1]+y[j]]=A[P[0][0]][P[0][1]]+1
            P.append([P[0][0]+x[j],P[0][1]+y[j]])
        elif A[P[0][0]+x[j]][P[0][1]+y[j]]<=A[P[0][0]][P[0][1]]+1:
            pass
        else:
            A[P[0][0]+x[j]][P[0][1]+y[j]]=A[P[0][0]][P[0][1]]+1
            P.append([P[0][0]+x[j],P[0][1]+y[j]])
    del P[0]
S=0
for i in range(H+2):
    for j in range(W+2):
        if A[i][j]=="#":
            S+=1
if A[H][W]==".":
    print(-1)
else:
    print((H+2)*(W+2)-S-A[H][W])
s, t = list(input().split().rstrip())
print(t + s)


### FIXED CODE ###

s, t = input().rstrip().split()
print(t + s)
data = input().split()

# ??????????????????????????????????£?
# n : ????????????????????????
# S : ????????????
n = 10
S = [0 for i in range(n)]

def isEmpty():
    global top
    if (top == 0):
        return True
    else:
        return False

def isFull():
    global top, n
    return top > n-1

def push(S, x):
    global top
    if isFull():
        print('error: overflow')
        return False
    top += 1
    S[top] = x

def pop(S):
    global top
    if isEmpty():
        print('error: underflow')
        return False
    top -= 1
    return S[top+1]

top = 0

for e in data:


    if e.isdigit():
        push(S, e)
    else:
        a = int(pop(S))
        b = int(pop(S))

        if e == '+':
            push(S, b + a)
        elif e == '-':
            push(S, b - a)
        elif e == '*':
            push(S, b * a)
        else:
            print('error: operand')


print(S[top])

### FIXED CODE ###

data = input().split()

# ??????????????????????????????????£?
# n : ????????????????????????
# S : ????????????
n = 1000
S = [0 for i in range(n)]

def isEmpty():
    global top
    if (top == 0):
        return True
    else:
        return False

def isFull():
    global top, n
    return top > n-1

def push(S, x):
    global top
    if isFull():
        print('error: overflow')
        return False
    top += 1
    S[top] = x

def pop(S):
    global top
    if isEmpty():
        print('error: underflow')
        return False
    top -= 1
    return S[top+1]

top = 0

for e in data:


    if e.isdigit():
        push(S, e)
    else:
        a = int(pop(S))
        b = int(pop(S))

        if e == '+':
            push(S, b + a)
        elif e == '-':
            push(S, b - a)
        elif e == '*':
            push(S, b * a)
        else:
            print('error: operand')


print(S[top])
x = int(input())
if x[n] ==0:
  print(n)

### FIXED CODE ###

print(15 - sum(list(map(int , input().split()))))
H, W = map(int, input().split())
field = [[i for i in input()] for j in range(H)]

b_rows = []
for row in range(H):
    if field[row].count(".") != W:
        b_rows.append(row)

b_columns = []
for column in range(W):
    memo = []
    for row in range(H):
        memo.append(field[column][row])
    if memo.count(".") != H:
        b_columns.append(column)

for i in b_rows:
    for j in b_columns:
        print(field[i][j], end="")
    print()

### FIXED CODE ###

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

b_rows = []
for row in range(H):
    if field[row].count(".") != W:
        b_rows.append(row)

b_columns = []
for column in range(W):
    memo = []
    for row in range(H):
        memo.append(field[row][column])
    if memo.count(".") != H:
        b_columns.append(column)

for i in b_rows:
    for j in b_columns:
        print(field[i][j], end="")
    print()
n = int(input())
vv = list(map(int, input().split(' ')))

vv.sort()

ans += vv[0]
for v in vv:
  ans += v
  ans /= 2
  
print(ans)

### FIXED CODE ###

n = int(input())
vv = list(map(int, input().split(' ')))
 
vv.sort()
 
ans = vv[0]
for v in vv[1:]:
  ans += v
  ans /= 2
  
print(ans)
import numpy as np

N, K = map(int, input().split(" "))
a = list(map(int, input().split(" ")))
a.insert(0, 0)
a_sum = np.tile(np.cumsum(np.array(a, dtype=np.int64)), (N+1, 1))
print(np.count_nonzero(a_sum - a_sum.T >= K))


### FIXED CODE ###

X, A = input().split(" ")
print(0 if X < A else 10)
n,a,b,c,d=map(int, input().split())
s=input()
v=0
x=0
for i in range(n-2):
    if c<d:
        if i>b and i<d and s[i]=='#' and s[i+1]=='#':
            print('No')
            v+=1
            break
 
    
    elif c>d:
        if  i>=b-1 and i<d+1 and s[i]=='.' and  s[i+1]=='.' and s[i+2]=='.' :
            x=1
            break
if x==0:
    print('No')
            
if x==1:
    for i in range(n-2):
        if i>b and i<c and s[i]=='#' and s[i+1]=='#':
            print('No')
            v+=1
            break
    if v==0:
        print('Yes')
if c<d and v==0:
    print('Yes')
n,a,b,c,d=map(int, input().split())
s=input()
v=0
x=0
for i in range(n-2):
    if c<d:
        if i>b and i<d and s[i]=='#' and s[i+1]=='#':
            print('No')
            v+=1
            break

    
    elif c>d:
        if  i>=b-1 and i<d+1 and s[i]=='.' and  s[i+1]=='.' and s[i+2]=='.' :
            x=1
            break
if x==0 and c>d:
    print('No')
            
if x==1:
    for i in range(n-2):
        if i>b and i<c and s[i]=='#' and s[i+1]=='#':
            print('No')
            v+=1
            break
    if v==0 and x==1:
        print('Yes')
if c<d and v==0:
    print('Yes')

### FIXED CODE ###

n, a, b, c ,d = map(int, input().split())
s = input()[:max(c,d)]
 
def main():
    if "##" in s[b:d-2]:
        return "No"
    if "##" in s[a:c-2]:
        return "No"
 
    if c < d:
        return "Yes"
    
    else:
 
        if "..." in s[b-2:d+1]:
            return "Yes"
                
        return "No"
 
print(main())
N, M = map(int, input().split())
A = [input() for i in range(N)]
B = [input() for i in range(M)]

ans = 'No'
for i in range(N):
    if A[i].find(B[0]) > -1:
        x = A[i].find(B[0])
        y = i + 1
        ans = 'Yes'
        break
for j in range(1, M):
    if B[j] != A[y][x:M]:
        ans = 'No'
print(ans)

### FIXED CODE ###

N, M = map(int, input().split())
A = [input() for i in range(N)]
B = [input() for j in range(M)]

ans = True
for k in range(len(B)):
    if B[k] not in A[k]:
        ans = False
        break
print("Yes" if ans == True else "No")