peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
s = list(input().split())

a = int(s[0])
b = int(s[1])
c = int(s[2])

sum = int(a+b+c)

if sum >= 22:
  print("bust")
else:
  print("win")
# Judge status: Accepted
n = int( input() )
a = list( map( int, input().split() ) )

cnt = [ 0 ] + [ 0 ] * n

for a_i in  a:
    cnt[a_i] += 1

all_combi = 0
for m in cnt:
    all_combi += m * ( m - 1 ) // 2

for k in range( 1, n+1 ):
    print( all_combi - ( cnt[a[k-1]] - 1 ) )
# Judge status: Wrong Answer
n = int(input())
if n == 1:
    print(1)
else:
    for i in range(1, n):
        if i**2 > n:
            print((i-1)**2)
            break
# Judge status: Accepted
N = int(input())
dic = {}
for _ in range(N):
    s = input()
    dic.setdefault(s, 0)
    dic[s] += 1
ans = list(dic.items())
ans.sort(key=lambda x: (-x[1], x[0]))
m = ans[0][1]
print("\n".join(i[0] for i in ans if i[1] == m))
# Judge status: Accepted
a = int(input())
for _ in range(3):
    _ = input()
e = int(input())
k = int(input())
if e-a<=k:
    print('Yay!')
else:
    print(':(')
# Judge status: Accepted
n = int(input())
s = input()
begin = 0
end = 0
for i in range(n):
    if s[i] == "(":
        begin += 1
    if s[i] == ")":
        if begin > 0:
            begin -= 1
            continue
        end += 1
print("("*end + s + ")"*begin)
# Judge status: Wrong Answer
n,m,x = map(int,input().split())
c=[]
for i in range(n):
  a=[int(i) for i in input().split()]
  c.append(a)
import numpy as np
c=np.array(c)
ans=float('inf')
for i in range(1,2**n):#0番目は[0][0][0]で購入しないので数えない
  p=[0]*m
  cost=0
  for j in range(n):
    if(i>>j)&1==1:
      cost+=c[j][0]
      p+=c[j][1:]
    if min(p)>=x:
      print(min(ans,cost))
      exit()
       
if ans==float('inf'):
  ans=-1
  print(ans)
# Judge status: Wrong Answer
a,b = list(map(int,input().split()))
if a % b == 0:
  print(a//b)
else:
  print(a//b+1)
# Judge status: Accepted
import numpy as np

N,D = map(int,input().split())
x = np.array([[int(i) for i in input().split()] for _ in range(N)])

count = 0
for i in range(N):
    for j in range(i+1,N):
        if float.is_integer(np.linalg.norm(x[i][:]-x[j][:], ord=2)):
            count += 1
print(count)
# Judge status: Wrong Answer
N = int(input())
for X in range(N):
    if int(X * 1.08) == N:
        print(X)
        exit()
print(":(")
# Judge status: Wrong Answer
T = input()
l = [t for t in T]

s = len(T)
for i in range(s):
  if l[i] == '?':
    if i == s-1:
      l[i] = 'D'
    elif (i==0) or ((l[i-1]=='D') and (l[i+1]=='D')):
      l[i] = 'P'
    else:
      l[i] = 'D'
      
str_changed = "".join(l)
print(str_changed)
# Judge status: Wrong Answer
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)
ate = p[0:X] +q[0:Y]
# print(ate)
for i in range(len(r)):
    if r[i] > ate[-1]:
        ate[-1] = r[i]
        ate.sort(reverse=True)
    else:
        break
print(sum(ate))
# Judge status: Wrong Answer
X = int(input())
if 360 % X == 0:
  print(int(360 / X))
else:
  total = 360
  while(True):
    if total % X == 0:
      break
    else:
      total += 360
  print(int(360 / X))
# Judge status: Wrong Answer
import sys
def Ii():return int(sys.stdin.readline())
def Mi():return map(int,sys.stdin.readline().split())
def Li():return list(map(int,sys.stdin.readline().split()))

ans = 0
n,d = Mi()
d = d*d
for i in range(n):
  x,y = Mi()
  if d > x**2+y**2:
    ans += 1
print(ans)
# Judge status: Accepted
Q, H, S, D = map(int, input().split())
Q *= 4
H *= 2
N = int(input())
print(N // 2 * min(Q * 2, H * 2, S * 2, D) + N % 2 * min(Q, H, S))
# Judge status: Accepted
N = int(input())
A  = list(map(int, input().split()))
ans = []
count = 0
i = 0
while i <= N-2:
  if A[i] >= A[i+1]:
    count += 1
    i += 1
  else:
    ans.append(count)
    count = 0
    i += 1
ans.append(count)
print(max(ans))
# Judge status: Wrong Answer
D, T, S = map(int, input().split())
if D<T*S:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
print((sum(map(int, input().split())) + 2 - 1) // 2)
# Judge status: Wrong Answer
H,W,N = [int(input()) for i in range(3)]
for o in range(1,10000):
  if H < W and  N / o<= W:
    break
  if H> W and N / o<=H:
    break
print(o)
# Judge status: Wrong Answer
from itertools import combinations as combi
N, X, Y = map(int, input().split(" "))

main_list = list(combi(list(range(1, N + 1)), 2))
dis_list = []

for c in main_list:
    x = c[0]
    y = c[1]
    if x <= X and y >= Y:
        dis_list.append((X - x) + (y - Y) + 1)
    else:
        dis_list.append(y - x)


for c in range(1, N, 1):
    print(dis_list.count(c))
# Judge status: Wrong Answer
n = int(input())
x = []
y = []
for _ in range(n):
    a,b = map(int,input().split())
    x.append(a)
    y.append(b)
ans = 0
for i in range(n):
    for j in range(n):
        print(i,j)
        ans += ((x[i]-x[j])**2 + (y[i]-y[j])**2)**0.5
print(ans/n)
# Judge status: Accepted
n = int(input())
al = list(map(int, input().split()))

ans = 0
while True:
    for i in range(n):
        if al[i] % 2 == 0:
            al[i] = al[i]//2
        else:
            break
    else:
        ans += 1
        continue
    break

print(ans)
# Judge status: Accepted
a = input()
if(str.isupper(a)):
  print('A')
else:
  print('a')
# Judge status: Wrong Answer
# A - Digits Sum

N = input()
N_int = int(N)
mylist = ['10','100','1000','10000','100000']
ans = 0

if N in mylist:
    ans = 0
else:
    for i in range(len(N)):
        ans += (N_int % 10)
        N_int = N_int // 10

print(ans)
# Judge status: Accepted
def main():
    n = int(input())
    a = list(map(int, input().split()))
    cnt = 0
    for i in range(n):
        if (i+1) % 2 == 1 and (a[i]) % 2 == 1:
            cnt += 1
    print(cnt)


main()
# Judge status: Accepted
def AnOddProblem():

    num = int(input())
    
    num_1 = list(map(int,input().split()))

    count = 0

    for i in range(num):
        mod_1 = num_1[i] % 2
        mod_2 = (i + 1) % 2
        
        if mod_1 == 1 and mod_2 == 1:
            count = count + 1
    
    print(count)

if __name__ == '__main__':
    AnOddProblem()
# Judge status: Accepted
n = int(input())
s = input()

MOD = 10**9 + 7

from collections import Counter

ctr = Counter(s)

ans = 1
for v in ctr.values():
    ans *= v + 1
    ans %= MOD
ans -= 1
ans %= MOD
print(ans)
# Judge status: Accepted
N, M, X = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
ans = float("inf")

for i in range(2**N):
    now = bin(i)[2:].zfill(N)  # now[i]: 参考書iを買う
    res = 0
    An = [0] * M
    for n in range(N):
        if now[n] == "1":
            res += A[n][0]
            An = [An[j] + A[n][j+1] for j in range(M)]
    if min(An) >= X:
        ans = min(ans, res)

if ans == float("inf"):
    print(-1)
else:
    print(ans)
# Judge status: Wrong Answer
n = input()
if (n == '3') or (n == '5') or (n == '7'):
 print("Yes")
else:
 print("No")
# Judge status: Wrong Answer
n,m = map(int,input().split())
a_all = []
b_all = []
for i in range(m):
    a,b = map(int,input().split())
    a_all.append(a-1)
    b_all.append(b-1)
for j in range(n):
    c = set()
    for k in range(m):
        if a_all[k] == j:
            c.add(b_all[k])
        if b_all[k] == j:
            c.add(a_all[k])
    print(len(c))
# Judge status: Wrong Answer
from collections import defaultdict
N = int(input())

anagrams = defaultdict(int)
for _ in range(N):
    chars = input()
    d = defaultdict(int)
    tuple_d = tuple(sorted(chars))
    if tuple_d in anagrams:
        anagrams[tuple_d] += anagrams[tuple_d]
    else:
        anagrams[tuple_d] += 1

print(sum([i-1 for i in anagrams.values()]))
# Judge status: Accepted
n = int(input())
print((10**n - 2*9**n + 8**n) % (10 ** 9 + 7))
# Judge status: Wrong Answer
n, k = map(int, input().split())
r, s, p = map(int, input().split())
S = input()
pt = []
for i in range(n):
    if S[i]=='r': t = p
    elif S[i]=='s': t = r
    else: t=s
    pt.append(t)
for i in range(k,n):
    if pt[i]==pt[i-k]:
        pt[i]=0
print(sum(pt))
# Judge status: Accepted
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

n=k()
if n == 1:
    print(1)
    sys.exit()

if n % 2==0:
    print((n/2)/n)
else:
    print((n//2+1)/n)
# Judge status: Wrong Answer
s = input()

if s == 'AAA':
	print('No')
if s == 'BBB':
	print('No')
else:
	print('Yes')
# Judge status: Accepted
import os
from itertools import permutations

def main():
	p_score, q_score, count = 0,0,0
	string = ""
	num = int(input())
	p_num = tuple(list(map(str, input().split())))
	q_num = tuple(list(map(str, input().split())))
	for i in range(1,num+1):
		string  = string + str(i) 
	list_ = list(permutations(string, num))
	
	for i in list_:

		count += 1
		if p_num == i:
			q_score = count
		if q_num == i:
			p_score = count
	
		
	print(abs(q_score - p_score))
		


if __name__ == '__main__':
	main()
# Judge status: Wrong Answer
from collections import defaultdict
N=int(input())
W=[]
for i in range(N):
  W.append(input())
  if i==0:
    continue
  if len(W)!=i+1:
    print('No')
    break
  if W[i][0]!=W[i-1][-1]:
    print('No')
    break
else:
  print('Yes')
# Judge status: Accepted
n,k = map(int,input().split())
li = list(map(int,input().split()))
li.sort()
print(sum(li[:k]))
# Judge status: Accepted
#n = int(input())
#s = input()
n, m = map(int,input().split())
da = list(map(int,input().split()))

now = 0
for i in range(m):
    now += da[i]/2 + 0.5
ans = now
for i in range(m,n):
    now -= da[i-m]/2 - da[i]/2
    ans = max(ans, now)
print(ans)
# Judge status: Accepted
N = input()
As = input().split(" ")

judge = True

for A in As:
    A=(int)(A)
    if A %2 ==0:
        if A%3 != 0 and A%5 != 0:
            judge=False
            break


if judge:
    print("APPROVED")
else:
    print("DENIED")
# Judge status: Wrong Answer
import sys
input = sys.stdin.readline
#-------------
S = input().split("/")
#-------------
print(S)
S = list(S)
print("2018" + "/" + S[1] + "/" + S[2])
# Judge status: Accepted
S = input()

for i in range(1, len(S)):
    gumozi = S[0:len(S)-i]

    if gumozi[0:len(gumozi)//2] == gumozi[(len(gumozi)//2):len(gumozi)]:
        print(len(gumozi))
        exit()
print(0)
# Judge status: Wrong Answer
a, b, c, d = map(int, input().split())

if b <= 0 and d <= 0:
    print(a * c)
elif a >= 0 and c >= 0:
    print(b * d)
elif b <= 0 and c >= 0:
    print(b * c)
elif d <= 0 and a >= 0:
    print(a * d)
else:
    print(b * d)
# Judge status: Wrong Answer
import math
import itertools
N = int(input())

xi = []
yi = []

for i in range(N):
    x, y = map(int, input().split())
    xi.append(x)
    yi.append(x)
    
result = 0
for i in range(N):
    for j in range(N):
            result += math.sqrt((xi[j] - xi[i])*(xi[j] - xi[i]) + (yi[j] - yi[i])*(yi[j] - yi[i]))
            
print(result/N)
# Judge status: Wrong Answer
n=int(input())
t=1
while t*t<n:
  t+=1
print(t)
# Judge status: Wrong Answer
# coding: utf-8
n, k = map(int, input().split())
ans = 1
while n > k:
    n = n // k
    ans = ans + 1
print(ans)
# Judge status: Accepted
N = int(input())
D = [input().split() for i in range(N)]
ans = 0
for i in range(N-2):
    if D[i][0] == D[i][1]:
        if D[i+1][0] == D[i+1][1]:
            if D[i+2][0] == D[i+2][1]:
                ans = 1
                break
if ans == 0:
    print('No')
else:
    print('Yes')
# Judge status: Accepted
from collections import Counter
n = int(input())
d = {}
for i in range(n):
    if i == 0:
        d = Counter(input())
    else:
        tmp = Counter(input())
        tmp2 = {}
        for k,v in d.items():
            if k in tmp:
                tmp2[k] = min(d[k],tmp[k])
        d = tmp2

ans = ""
for k,v in d.items():
    ans += v*k

print(''.join(map(str, sorted(ans))))
# Judge status: Wrong Answer
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
a = sorted(LI())
print(sum(a[N:2*N]))
# Judge status: Accepted
import copy
n = int(input())
a = []
for _ in range(n):
    a.append(int(input()))

M = max(a)
b = a.count(M)
if b >=2:
    for i in range(n):
        print(M)
else:
    A = copy.copy(a)
    for i in range(b):
        a.remove(M)
        m = max(a)
    for i in A:
        if i == M:
            print(m)
        else:
            print(M)
# Judge status: Accepted
def main():
    S = input()
    T = input()
    
    if S == T:
        print("Yes")
    else:
        same = False
        for i in range(len(S)):
            S = S[-1] + S[:len(S)-1]
            if S == T:
                print("Yes")
                same = True
                break
        if same == False:
            print("No")
main()
# Judge status: Accepted
s = input()
t = input()

sl = len(s)
tl = len(t)
cnt = 0
ans = []
while(cnt + tl <= sl):
  tmp = 0
  for i in range(tl):
    if((s[cnt+i] == t[i]) or s[cnt+i] == '?'):
      tmp += 1
  if(tmp == tl):
    
    ans = list(s)
    ans[cnt:cnt+tl] = t
    
  cnt+=1
if(len(ans) == 0):
  print("UNRESTORABLE")
  exit()
  
for i in range(sl):
  if(ans[i] == '?'):
    ans[i] = 'a'
print("".join(ans))
# Judge status: Accepted
N = input()
a = list(N)
for i in range(len(a)):
    a[i] = int(a[i])
p = 1
for i in range(len(a)):
    if a[i] == 7:
        p = p*0
if p == 0:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
a,b,k=map(int,input().split())
if a>=k:
  print(a-k,b)
elif a-k<=0 and b-k+a>=0:
  print('0',b-k+a)
elif a-k<0 and b-k+a<0:
  print('0','0')
# Judge status: Accepted
N, L = map(int, input().split())
tmp = []
for i in range(N):
    tmp.append(input())
tmp.sort()
#print(tmp)
print("".join(i for i in tmp))
# Judge status: Accepted
n = int(input())
dp = [0] * (n + 1)
for x in range(1, n + 1):
    for y in range(x, n + 1, x):
        dp[y] += 1
print(sum(dp[1:n]))
# Judge status: Accepted
s, w = map(int, input().split())
if s > w:
    print('safe')
else:
    print('unsafe')
# Judge status: Accepted
n,k=map(int,input().split())
num=k
cnt=1
while(n>num):
    num+=(k-1)
    cnt+=1
print(cnt)
# Judge status: Accepted
alpha = [chr(ord('a') + i) for i in range(26)]

S = set(input())

if len(set(alpha)) == len(S):
    print('None')
else:
    for s in alpha:
        if s not in S:
            print(s)
            exit()
# Judge status: Wrong Answer
from collections import Counter
c = Counter(input())
for vi in c.values():
    for vj in c.values():
        if abs(vi-vj) > 1:
            print("NO")
            quit(0)
print("YES")
# Judge status: Accepted
import sys
A,B = map(int,input().split())
sys.setrecursionlimit(2000)
def search(x):
    p = (x*0.08)//1
    q = (x*0.10)//1
    if p==A and q==B:
        print(x)
        exit()
    elif p > A and q > B:
        print(-1)
    else:
        search(x+1)
search(1)
# Judge status: Accepted
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():
    N = in_n()
    a = list(in_nn())

    s = a[0]
    for i in range(1, N):
        s = s ^ a[i]

    ans = [0] * N
    for i in range(N):
        ans[i] = a[i] ^ s

    print(' '.join(map(str, ans)))


if __name__ == '__main__':
    main()
# Judge status: Accepted
n,c,k = map(int,input().split())
t = 0
cnt = c
ans = 0
T = [int(input()) for _ in range(n)]
T.sort()
for i in range(n):
    if cnt == c or T[i] > t:
        ans += 1
        t = T[i] + k
        cnt = 1
    else:
        cnt += 1

print(ans)
# Judge status: Accepted
x = int(input())

cnt = 0

for i in range(1, 100000000):
    cnt += i
    if cnt >= x:
        ans = i
        break

print(ans)
# Judge status: Wrong Answer
n, m, x = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]

min = float('inf')

for i in range(1<<n): # 1<<n == 2**n
    study = [0 for _ in range(m)]
    cost = 0

    for j in range(n):
        if i&(1<<j):
            cost += a[j][0]
            study = [study[k]+a[j][k] for k in range(m)]

    if(all([s >= x for s in study])):
        if min > cost:
            min = cost

if float('inf') > min:
    print(min)
else:
    print(-1)
# Judge status: Wrong Answer
N = int(input())
L = []
D = {}
for _ in range(N):
  k, v = input().split()
  L.append((k, v))
  if k not in D.keys():
    D[k] = [v]
  else:
    D[k].append(v)
for v in D.values():
  v.sort(reverse=True)
D = sorted(D.items(), key=lambda x: x[0])
for d in D:
  for i in range(len(d[1])):
    print(L.index((d[0], d[1][i]))+1)
# Judge status: Wrong Answer
a,b = map(int, input().split())
if b%a==0 or a%b==0:
  print(b)
else:
  print(a*b)
# Judge status: Wrong Answer
N = int(input())
best_count = 0
ans = 0

while (N > 0):
  n = N
  count = 0
  while(True):
    if n % 2 != 0:
      break
    else:
      n /= 2 
      count += 1
  if count > best_count:
    ans = N
    best_count = count
  N -= 1
  
print(ans)
# Judge status: Accepted
s = input()
if s[0] != s[1] and s[1] != s[2] and s[2] != s[0]:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
N = int(input())
a = list(map(int,input().split()))

ans = 0

if N == 1:
  ans = 1
elif N == 2:
  if max(a)-min(a) <= 2:
    ans = 2
  else:
    ans = 1
else:
  for x in range(min(a),max(a)-1):
    ans_candidate = a.count(x)+a.count(x+1)+a.count(x+2)
    if ans < ans_candidate:
      ans = ans_candidate
print(ans)
# Judge status: Wrong Answer
n, a, b = map(int, input().split())

if n == 0 or n == 1:
    print(0)
    exit(0)
print(b*(n-2) - a*(n-2) + 1)
# Judge status: Accepted
n, m = map(int, input().split())
ans = (n * (n - 1)) // 2 + (m * (m - 1)) // 2
print(ans)
# Judge status: Accepted
s = input()
a = s.count('a')
b = s.count('b')
c = s.count('c')
x = (len(s)-1)//3+1
if a <= x and b <= x and c <= x:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
from collections import deque
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

l,r,d = NextInts()

ans = 0
for i in range(l,r+1):
    if i%d == 0:
        ans += 1
print(ans)
# Judge status: Wrong Answer
n,k,q = map(int,input().split())
lst = [int(input()) for _ in range(q)]
for i in range(n+1):
    score = k-q+lst.count(i)
    print("Yes" if score > 0 else "No")
# Judge status: Accepted
N = int(input())
int_list = [int(x) for x in input().split()]

# int_listの各整数をyに書き換えるときのコストの総和を計算
def calc_cost(int_list, y):
    cost = 0
    for x in int_list:
        cost += (x - y)**2
    return cost

cost_list = [calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]
print(min(cost_list))
# Judge status: Accepted
#!/usr/bin/env python3
import math

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

data = []

for _ in range(N):
    a, b = map(int, input().split())
    data.append([a, True])
    data.append([b, False])

data = sorted(data)[::-1]
ans = 0

for d in data:
    flag = d[1]
    if flag:
        ans += math.ceil(H / d[0])
        break
    else:
        ans += 1
        H -= d[0]
        if H <= 0:
            break
    
print(ans)
# Judge status: Accepted
n = int(input())
x = list(map(int, input().split()))
xx = sorted(x, reverse=True)

m1 = xx[n//2-1]
m2 = xx[n//2]

# print(m1, m2)

for i in range(len(x)):
    if x[i] < m1:
        print(m1)
    elif x[i] >= m1:
        print(m2)
# Judge status: Wrong Answer
N, Y = map(int, input().split())

if Y // 1000 == N:
  print(0, 0, N)

man_max = Y // 10000
gosen_max = Y // 5000

is_exist = False

for i_m in range(man_max+1):
  for i_g in range(gosen_max+1):
    if 9000*i_m + 4000*i_g == Y - 1000*N:
      print(i_m, i_g, int(Y / 1000 - 10*i_m - 5*i_g))
      is_exist = True
      exit()
      
print(-1, -1, -1)
# Judge status: Accepted
import collections 
N = int(input())
lsA = []
for i in range(N):
    lsA.append(int(input()))
counterA = collections.Counter(lsA)
ans = 0
for i in counterA.values():
    ans += i%2
print(ans)
# Judge status: Accepted
n, m = map(int, input().split())
ps = [list(map(str, input().split())) for i in range(m)]

AC =[0]*n
WA = [0]*n
WA_ans = [0]*n

for i in range(m):
    if AC[int(ps[i][0])-1] == 0:
        if ps[i][1] == 'AC':
            AC[int(ps[i][0])-1] = 1
            WA_ans[int(ps[i][0])-1] = WA[int(ps[i][0])-1]

        elif ps[i][1] == 'WA':
            WA[int(ps[i][0])-1] += 1

print(sum(AC), sum(WA_ans))
# Judge status: Wrong Answer
s = list(input())

g = []

g.append(0)
g.append(1)
if len(s) > 1:
    if s[1] == s[2]:
        g.append(1)
    else:
        g.append(2)

    for i in range(3,len(s)+1):
        if s[i-1] != s[i-2]:
            g.append(g[i-1]+1)
        else:
            g.append(g[i-3]+2)

print(g[len(s)])
# Judge status: Accepted
a,b=map(int,input().split())
if a>=13:
    print(b)
elif a>=6:
    print(b//2)
else:
    print(0)
# Judge status: Accepted
A, B = [s for s in input().split()]
A = int(A)
intB, decimalB = B.split(".")
result = A * int(intB) +  A * int(decimalB) // 100
print(result)
# Judge status: Accepted
n = int(input())
s = input()
t = input()

for i in range(n):
   if s[i:] == t[:n-i]:
       print(n+i)
       exit()

print(2*n)
# Judge status: Wrong Answer
X = int(input())
if X == 7 or 5 or 3:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
from queue import Queue
K = int(input())
q = Queue()
for i in range(1, 10):
    q.put(i)
for _ in range(K-1):
    x = q.get()
    n = x * 10
    m = x % 10
    if x % 10:
        q.put(n + m - 1)
    q.put(n + m)
    if x % 10 != 9:
        q.put(n + m + 1)
print(q.get())
# Judge status: Accepted
N = int(input())
#葉
A = list(map(int,input().split()))
s = sum(A[1:])
B = [0] * (N+1)
B[0] = 1 - A[0]
for i in range(0,N):
    s -= A[i+1]
    if 2*B[i] < A[i+1]:
        print("-1")
        exit()
    B[i+1] = min(2*B[i]-A[i+1],s)
if B[-1] != 0:
    print("-1")
else:
    print(sum(A)+sum(B))
# Judge status: Wrong Answer
n = int(input())
if n % 2 == 0:
    print(n * n)
else:
    a = n // 2
    print(a * (n-a))
# Judge status: Accepted
a, b = map(int, input().split())
if a <= 8 and b <= 8:
  print('Yay!')
else:
  print(':(')
# Judge status: Wrong Answer
w, a, b = map(int, input().split())

if a < b < a + w:
    print(0)
elif a < b + w < a + w:
    print(0)
elif b < a < b + w:
    print(0)
elif b < a + w < b + w:
    print(0)
elif a + w < b:
    print(b - (a + w))
elif b + w < a:
    print(a - (b + w))
# Judge status: Wrong Answer
n=int(input())
if n==7 or n==5 or n==3:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n=int(input())
cnt=0

for i in range(1, n+1):
    l=len(str(i))
    if l%2==1:
        cnt+=1

print(cnt)
# Judge status: Accepted
N = int(input())
S = input()

# 西端の人がリーダーの場合
temp = 0
for j in range(1, N):
    temp += (S[j] == 'E')
    ans = temp

for i in range(1, N): # 西からi番目の人がリーダーの場合
    temp -= (S[i] == 'E')
    temp += (S[i - 1] == 'W')
    ans = min(ans, temp)

print(ans)
# Judge status: Accepted
import sys
input=sys.stdin.readline

s=int(input())

#0<= x,y <=10**9
#s/2

if s<=10**9:
    print(0,0,1,0,0,s)
    exit()

y=(-1*s//(10**9))*(-1)
x=10**9*y-s

print(0,0,10**9,1,x,y)
# Judge status: Accepted
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()

d = {'r': P, 's': R, 'p': S}
result = 0
wins = [False] * K
for i in range(len(T)):
    if not wins[i % K] or T[i] != T[i - K]:
        result += d[T[i]]
        wins[i % K] = True
    else:
        wins[i % K] = False
print(result)
# Judge status: Wrong Answer
a, b = map(int, input().split())
if max(a,b) <= 12:
    print(min(a,b))
else:
    print(a)
# Judge status: Accepted
l = list(map(int, input().split()))

print(len(set(l)))