Harryxun/stf_run huggingface dataset:
import itertools
n = int(input())
c1 = tuple(map(int, input().split()))
c2 = tuple(map(int, input().split()))
a = []
for i in range(1,n+1):
    a.append(i)
b = sorted(list(itertools.permutations(a)))
for i in range(len(b)):
    if b[i] == c1:
        d = i
    elif b[i] == c2:
        e = i
print(abs(d-e))

### FIXED CODE ###

import itertools
n = int(input())
c1 = tuple(map(int, input().split()))
c2 = tuple(map(int, input().split()))
a = []
for i in range(1,n+1):
    a.append(i)
b = sorted(list(itertools.permutations(a)))
for i in range(len(b)):
    if b[i] == c1:
        d = i
    if b[i] == c2:
        e = i
print(abs(d-e))
n = int(input())
a = n * 2 * math.pi
print(a)


### FIXED CODE ###

import math
n = int(input())
a = n * 2 * math.pi
print(a)
[d,n] = x.split(' ')
if int(d) == 0:
    if int(n) == 100:
        print(101)
    else:
        print(n)
elif int(d)==1 or int(d)==2:
    if int(n) == 100:
        print((100**int(d))*(int(n)+1))
    else:
        print((100**int(d))*int(n))

### FIXED CODE ###

import sys
x = sys.stdin.readline()

[d,n] = x.split(' ')
if int(d) == 0:
    if int(n) == 100:
        print(101)
    else:
        print(n)
elif int(d)==1 or int(d)==2:
    if int(n) == 100:
        print((100**int(d))*(int(n)+1))
    else:
        print((100**int(d))*int(n))
l,r=map(int,input().split())
s=[]
if ((r//2019)!=(l//2019)):
        a=0
    s.append(a)
elif((r-l!=1)):
    for i in range(l,r-1):
        for j in range(l+1,r):
            #print(i,j)
            a=(i*j)%2019
            #print(a)
            s.append(a)
            if (a==0):
                break
else:
    a=(l*r)%2019
    s.append(a)
print(min(s))



### FIXED CODE ###

l,r=map(int,input().split())
s=[]
if ((r//2019)!=(l//2019)):
    a=0
    s.append(a)
elif((r-l!=1)):
    for i in range(l,r-1):
        for j in range(i+1,r+1):
            #print(i,j)
            a=(i*j)%2019
            #print(a)
            s.append(a)
            if (a==0):
                break
else:
    a=(l*r)%2019
    s.append(a)
print(min(s))
n = str(input())
num = []
from functools import reduce
num = [str(x) for x in list(str(n))]
x = o
for i in num:
  if i == "+":
    x = x + 1
  else:
    x = x - 1
print(x)

### FIXED CODE ###

n = str(input())
num = []
from functools import reduce
num = [str(x) for x in list(str(n))]
x = 0
for i in num:
  if i == "+":
    x = x + 1
  else:
    x = x - 1
print(x)
import math
hoge = list(input().split())
A = int(hoge[0])
B1 = int(hoge[1])
B2 = (float(hoge[1])-B1)*100
ans = A*B1 + A*B2//100
print(ans)

### FIXED CODE ###

A, B = input().split()
A = int(A)
B1, B2 = map(int, B.split('.'))
ans = A*B1 + A*B2//100
print(ans)
import math

N = int(input())

S = round(N**2*math.pi, 6)
R = round(2*math.pi*N, 6)

print(S, R)

### FIXED CODE ###

import math

r = float(input())

s = r*r*math.pi
v = 2*math.pi*r

S = round(s, 6)
V = round(v, 6)

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

for i in range(n):
    print(a.count(a)\n)
    


### FIXED CODE ###

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

lis = [0] * n
for i in A:
  lis[i-1] += 1

for j in range(len(lis)):
  print(lis[j])
A = int(input())
B = int(input())
A*B

### FIXED CODE ###

x, y = map(int, input().split())
print(x*y)
N, P = map(int, input().split())
S = input()

if P == 2 or P == 5:
    import sys
    sys.exit(1)
    ans = 0
    for i, s in enumerate(S):
        if int(s) % P == 0:
            ans += i+1
    print(ans)

val = int(S)
order = 10 ** N
suf_nums = [-1] * N
s = -1
for i in range(N):
    if s != -1:
        val -= s * order
    suf_nums[i] = val
    s = int(S[i])
    order //= 10

surpluses = [0] * P
ans = 0
suf_nums.reverse()
for num in suf_nums:
    surplus = num % P
    surpluses[surplus] += 1
    if surplus == 0:
        ans += surpluses[0]
    else:
        ans += surpluses[surplus] - 1

print(ans)



### FIXED CODE ###

N, P = map(int, input().split())
S = input()

if P == 2 or P == 5:
    ans = 0
    for i, s in enumerate(S):
        if int(s) % P == 0:
            ans += i+1
    print(ans)
    import sys
    sys.exit(0)

surpluses = [0] * P
s = 0
power = 1
for i in range(N):
    s = (s + int(S[-1-i]) * power) % P
    surpluses[s % P] += 1
    power = (power * 10) % P

ans = surpluses[0]
for count in surpluses:
    ans += count * (count - 1) // 2

print(ans)
a, b =list(map(int,input().split())
print("{} {}".format(a*b,2*(a+b)))


### FIXED CODE ###

a, b =list(map(int,input().split()))
print("{} {}".format(str(a*b),str(2*(a+b))))
l=[]
for i in range(10):
	l.append(int(input()))
l.sort().reverse()
print(l[0])
print(l[1])
print(l[2])

### FIXED CODE ###

l=[]
for i in range(10):
	l.append(int(input()))
l.sort(reverse=True)
print(l[0])
print(l[1])
print(l[2])
c = raw_input()



ls = [chr(ord('a') + i) for i in range(26)]

for i in range(len(ls)):
    if ls[i] == c:
        print(ls[i + 1])
        break



### FIXED CODE ###



c = input()



ls = [chr(ord('a') + i) for i in range(26)]

for i in range(len(ls)):
    if ls[i] == c:
        print(ls[i + 1])
        break
a = int(input())
b = int(input())
cin>>a>>b;
c = int()
c = a * b
if c % 2 == 1:
    print("Odd")
elif c % 2 == 0:
    print("Even")

### FIXED CODE ###

a , b = map(int , input().split())
if a * b % 2 == 1:
    print("Odd")
elif a * b % 2 == 0:
    print("Even")
import itertools;n,m,q,*l=map(int,open(0).read().split());print(max(sum(d for a,b,c,d in l[::4]if i[b-1]-i[a-1]==c)for i in itertools.combinations_with_replacement(range(m),n)))

### FIXED CODE ###

import itertools
n,m,q=map(int,input().split())
abcd=[list(map(int,input().split()))for _ in range(q)]
ans=0
for i in itertools.combinations_with_replacement(range(m),n):
  anss=0
  for a,b,c,d in abcd:
    if i[b-1]-i[a-1]==c:anss+=d
  ans=max(ans,anss)
print(ans)
import sys; sys.setrecursionlimit(50000)
input = sys.stdin.readline

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)

cnt = 0
result = [0]*200000
for x in range(X):
    for y in range(Y):
        if x * y > K: break
        for z in range(Z):
            if x * y * z > K: break
            result[cnt] = A[x]+B[y]+C[z]
            cnt += 1
result.sort(reverse=True)
for i in range(K):
    print(result[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()))

import itertools
AB = [a + b for a, b in itertools.product(A,B)]
AB.sort(reverse=True)
ABC = [ab + c for ab, c in itertools.product(AB[:3000],C)]
ABC.sort(reverse=True)
for i in range(K):
    print(ABC[i])
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))

a.sort()
ans = 0

for i in range(N):
  if a[-1 -i] < K:
    break
  ans += 1

n = N - ans
D = []
re = a[0]
cnt = 0
for i in range(n):
 if re == a[i]:
   cnt += 1
 else:
   D.append([re, cnt])
   cnt = 1
 re = a[i]
else:
  D.append([re, cnt])

L = [{} for _ in range(2 * K)]
M = [[0] * (2 * K) for _ in range(2 * K)]
for i in D:
  for j in range(i[1]):
    if i[0] * (j + 1) >= 2 * K:
      break
    L[i[0] * (j + 1)][i[0]] = 1
    M[i[0] * (j + 1)][i[0]] = 1

for i in D:
  for j in range(i[1]):
    for k in range(K):
      t = i[0] * (j + 1)
      if k + t >= 2 * K:
        break
      if len(L[k]) > 0:
        if M[k][t] == 0:
          for l in L[k].keys():
            M[k + t][l] = 1
            L[k + t][l] = 1
          M[k + t][t] = 1
          L[k + t][l] = 1

for i in D:
  for j in range(K, K + i[0]):
    if len(L[j]) > 0 and M[j][i[0]] == 1:
      ans += i[1]
      break

print(N - ans)



### FIXED CODE ###

def hersCode(l, r):
  ok = r
  ng = l - 1
  while ok - ng > 1:
    mid = (ok + ng) // 2
    if nasu(a[mid]):
      ok = mid
    else:
      ng = mid
  return ok

def nasu(x):
  if x >= K:
    return True
  D = [0] * K
  L = [0]
  f = 0
  for i in a:
    if i == x and f == 0:
      f = 1
      continue
    for jj in range(len(L) - 1, -1, -1):
      j = L[jj]
      if i + j < K:
        if i + j + x >= K:
          return True
        if D[i + j] == 0:
          D[i + j] = 1
          L.append(i + j)
  return False


N, K = list(map(int, input().split()))
a = list(map(int, input().split()))

a.sort()
a.append(10 ** 9 + 1)
ans = hersCode(0, N)
print(ans)
def main():
  n, k = map(int, input().split())

  plus = []
  minus = []

  for num in input().split():
    num = int(num)
    if num >= 0:
      plus.append(num)
    else:
      minus.append(num)

  pn = len(plus)
  mn = len(minus)

  mod = 10 ** 9 + 7

  if pn == 0 and k % 2 == 1:
    minus.sort(reverse = True)
    ans = 1
    for i in range(k):
      ans = (-ans * minus[i]) % mod

    print((-ans) % mod)
    return


  plus.sort(reverse = True)
  minus.sort()

  pi = 0
  mi = 0

  while k > 0:
    if pi + 1 == pn:
      if k % 2 == 0:
        mi += k
      else:
        pi += 1
        mi += k - 1

      break

    if pi == pn:
      mi += k
      break

    if mi + 1 >= mn:
      pi += k
      break

    if k == 1 or plus[pi] * plus[pi + 1] >= minus[mi] * minus[mi + 1]:
      pi += 1
      k -= 1
    else:
      mi += 2
      k -= 2

  ans = 1
  for i in range(pi):
    ans = (ans * plus[i]) % mod

  for i in range(mi):
    ans = (-ans * minus[i]) % mod

  print(ans % mod)


main()


### FIXED CODE ###


def main():
  n, k = map(int, input().split())

  mod = 10 ** 9 + 7

  if n == k:
    ans = 1
    for num in input().split():
      ans = (ans * int(num)) % mod

    print(ans % mod)
    return

  plus = []
  minus = []
  for num in input().split():
    num = int(num)
    if num >= 0:
      plus.append(num)
    else:
      minus.append(num)

  pn = len(plus)
  mn = len(minus)

  if pn == 0 and k % 2 == 1:
    minus.sort(reverse = True)
    ans = 1
    for i in range(k):
      ans = (-ans * minus[i]) % mod

    print((-ans) % mod)
    return


  plus.sort(reverse = True)
  minus.sort()

  pi = 0
  mi = 0

  while k > 0:
    if pi + 1 == pn:
      if k % 2 == 0:
        mi += k
      else:
        pi += 1
        mi += k - 1

      break

    if pi == pn:
      mi += k
      break

    if mi + 1 >= mn:
      pi += k
      break

    if k == 1 or plus[pi] * plus[pi + 1] >= minus[mi] * minus[mi + 1]:
      pi += 1
      k -= 1
    else:
      mi += 2
      k -= 2

  ans = 1
  for i in range(pi):
    ans = (ans * plus[i]) % mod

  for i in range(mi):
    ans = (-ans * minus[i]) % mod

  print(ans % mod)


main()
S = list(map(str, input()))
cnt = 0
CNT = []
for i in range(len(S)):
    if S[i]=='A' or S[i]=='C' or S[i]=='G' or S[i]=='T':
        cnt += 1
    if S[i]!='A' and S[i]!='C' and S[i]!='G' and S[i]!='T':
        CNT.append(cnt)
        cnt = 0

print(max(CNT))

### FIXED CODE ###

S = list(map(str, input()))
cnt = 0
CNT = []
for i in range(len(S)):
    if S[i]=='A' or S[i]=='C' or S[i]=='G' or S[i]=='T':
        cnt += 1
        if i==len(S)-1:
            CNT.append(cnt)
    if S[i]!='A' and S[i]!='C' and S[i]!='G' and S[i]!='T':
        CNT.append(cnt)
        cnt = 0

print(max(CNT))
from math import *
log = lambda *x: print(*x)

n, = cin(int)
h, = cin(int)
w, = cin(int)

tw, th = 0, ceil(n/h)

while w <= n:
    tw += 1
    w += 1

log(th * tw)


### FIXED CODE ###

from math import *
log = lambda *x: print(*x)

def cin(*fn, def_fn=str):
    i, r = 0, []
    if fn:
        def_fn = fn[0]
    for c in input().split(' '):
        r += [(fn[i] if len(fn) > i else def_fn) (c)]
        i += 1
    return r
##################################################

n, = cin(int)
h, = cin(int)
w, = cin(int)

tw, th = 0, 0

while h <= n:
    h += 1
    th += 1

while w <= n:
    tw += 1
    w += 1

log(th * tw)
ops ??????{"+": lambda a, b: b + a,
        "-": lambda a, b: b - a,
        "*": lambda a, b: b * a,
        "/": lambda a, b: flaot(b)/a}
stack = []
for s in input().split():
    if s in ops:
        stack.append(ops[s](stack.pop(),stack.pop()))
    else:
        stack.append(int(s))
print stack[-1]

### FIXED CODE ###

ops={"+": lambda a, b: b + a,
        "-": lambda a, b: b - a,
        "*": lambda a, b: b * a,
        "/": lambda a, b: flaot(b)/a}
stack = []
for s in input().split():
    if s in ops:
        stack.append(ops[s](stack.pop(),stack.pop()))
    else:
        stack.append(int(s))
print(stack[-1])
def nn(n):
    if n==0:
        return 1
    else:
        return n*nn(n-1)

n=int(input())
ans=nn(n)%100000007
print(ans)

### FIXED CODE ###

N = int(input())
C = 10**9+7
ans = 1
for i in range(1, N + 1):
    ans *= i
    ans %= C
print(ans)
def count(S, m, n): 
    table = [0 for k in range(n+1)] 
  
    table[0] = 0
    if n <= 100:
        return 0
    if n <= 105:
        return 1

    table[100] = 1
    table[101] = 1
    table[102] = 1
    table[103] = 1
    table[104] = 1
    table[105] = 1

    for i in range(0,m): 
        for j in range(S[i],n+1): 
            table[j] += table[j-S[i]] 
  
    return table[n] 
  
def main():
    X = int(input())
    S = [100, 101, 102, 103, 104, 105, 106] 

    if count(S, 8, X):
        print(1)
    else:
        print(0)
    
if __name__ == "__main__":
    main()


### FIXED CODE ###

def count(S, m, n): 
    if n < 100:
        return 0

    table = [False for k in range(n+1)]   
    table[100:106] = [True] * 6

    for i in range(106, n+1):
        table[i] = any([table[i-j] for j in range(S[0], S[-1]+1)])
  
    return 1 if table[n] else 0
  
def main():
    X = int(input())
    S = [100, 101, 102, 103, 104, 105] 
    print(count(S, len(S), X))

if __name__ == "__main__":
    main()
r, g, b, n = map(int, input().split())
count = 0

for i in range(n + 1):
    for j in range(n + 1):
        total = n - r * i - g * j
        if total < 0:
            break
        if total % b == 0:
            count += 1

print(count)


### FIXED CODE ###

import bisect
import numpy as np
import scipy as sp
from sys import stdin

n, k = map(int, input().split())
print(n - k + 1)
first = sorted(list(input('')))
second = sorted(list(input('')), reverse=True)
length = len(first) < len(second)

result = False
check_equal = False
for (f, s) in zip(first, second):
  check_equal = (s == f)
  if !check_equal:
    result = (f < s)
    break

if (length and check_equal) or result:
  print('Yes')
else:
  print('No')


### FIXED CODE ###

first = sorted(list(input('')))
second = sorted(list(input('')), reverse=True)
length = len(first) < len(second)

result = False
check_equal = False
for (f, s) in zip(first, second):
  check_equal = (s == f)
  if f < s:
    result = True
    break
  elif f > s:
    result = False
    break

if (length and check_equal) or result:
  print('Yes')
else:
  print('No')
n = int(input())
a_ls = list(map(int, input().split()))
a_ls.sort(reverse=True)
ans = 0
for i in range(n):
    not_divisible = True
    for j in range(i+1,n):
        if a_ls[i] % a_ls[j] == 0:
            not_divisible = False
            break
    if not_divisible:
        ans += 1
if a_ls[-2] == a_ls[-1]:
    ans -= 1
print(ans)

### FIXED CODE ###

n = int(input())
a_ls = list(map(int, input().split()))
a_ls.sort()
a_max = a_ls[-1]
times_ls = [0] * (a_max + 1)
divisible_ls = [0] * (a_max + 1)
for i in range(n):
    base = a_ls[i]
    times_ls[base] += 1
    times = 2
    while base*times <= a_max:
        divisible_ls[base*times] = 1
        times += 1
ans = 0
for i in range(1,a_max+1):
    if times_ls[i] == 1 and divisible_ls[i] == 0:
        ans += 1
print(ans)
import sys

class Stack:
    def __init__(self, max):
        self.max = max  ##max???stack????????§??????
        self.stack = list(range(max)) 
        self.top = 0  ##???????????????????????????0

    def initialize():
        self.top = 0

    def isEmpty():
        return self.top == 0

    def isFull():
        return self.top >= self.max - 1

    def push(self, value):
        if isFull():
            raise IndexError('?????????????????????')
        else:
            self.top += 1
            self.stack[self.top] = value

    def pop(self):
        if isEmpty():
            raise IndexError('??¢??????????????????')
        else:
            self.top -= 1
            return self.stack[self.top + 1]


expr = input().split()
stack = Stack(100)

for i in expr:
    try:
        stack.push(int(i))
    except:
        b = stack.pop()
        a = stack.pop()
        if i == '*':
            stack.push(a * b)
        if i == '+':
            stack.push(a + b)
        if i == '-':
            stack.push(a - b)

print(stack.pop())
                

### FIXED CODE ###

x = input().split()
A = []
for i in x:
    try:
        A.append(int(i))
    except:
        b = A.pop()
        a = A.pop()
        if i == '+':
            A.append(a + b)
        if i == '-':
            A.append(a - b)
        if i == '*':
            A.append(a * b)
print(A.pop())
x, k, d = ma-(int, input().split())
x = abs(x)

if x>k*d:
    print(x-k*d)
else:
    k-=x//d
    x-=(d*(x//d))
    and=[x,abs(d-x)]
    print(ans[k%2])

### FIXED CODE ###

x,k,d=map(int,input().split())
x=abs(x)
if x>k*d:
    print(x-k*d)
else:
    k-=x//d
    x-=(d*(x//d))
    ans=[x,abs(d-x)]
    print(ans[k%2])
import sys
import math 

def be_able_to_convey(w, k, p):
	counter = 0
	cur_weight = 0
	for wi in w:
		if wi > p:
			return False

		cur_weight += wi
		if(cur_weight > p):
			cur_weight = wi
			counter += 1
			if(counter >= k):
				return False

	return True

fin = open("test.txt", "r")
#fin = sys.stdin

n, k = map(int, fin.readline().split())
w = [0 for i in range(n)]
w_max = 0

for i in range(n):
	w[i] = int(fin.readline())
	w_max = max(w[i], w_max)
	

pmin = 1
pmax = math.ceil(w_max * w_max // k)

while pmin < pmax:
	p = math.ceil((pmin + pmax) / 2)
	if p == pmin or p == pmax:
		if be_able_to_convey(w, k, pmax):
			if be_able_to_convey(w, k, pmin):
				p = pmin
			else:
				p = pmax
		else:
			p = pmin
		break

	if not be_able_to_convey(w, k, p):
		pmin = p
	else:
		pmax = p

print(p)

### FIXED CODE ###

import sys
import math 

def be_able_to_convey(w, k, p):
	counter = 0
	cur_weight = 0
	for wi in w:
		if wi > p:
			return False

		cur_weight += wi
		if(cur_weight > p):
			cur_weight = wi
			counter += 1
			if(counter >= k):
				return False

	return True

#fin = open("test.txt", "r")
fin = sys.stdin

n, k = map(int, fin.readline().split())
w = [0 for i in range(n)]

for i in range(n):
	w[i] = int(fin.readline())
	
pmin = 1
pmax = int(10e9)

while pmin < pmax:
	p = math.ceil((pmin + pmax) / 2)
	if p == pmin or p == pmax:
		if be_able_to_convey(w, k, pmin):
			p = pmin
		else:
			#if not be_able_to_convey(w, k, pmax):
			#	print("error")
			p = pmax
		break

	if not be_able_to_convey(w, k, p):
		pmin = p
	else:
		pmax = p

print(p)
import sys

str = sys.stdin.readline()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])

### FIXED CODE ###

str = input()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[ord(str)-96])
# -*- coding: utf-8 -*-
N = int(input())
L = list(map(int, inpout().split()))
if max(L) > (sum(L)-max(L)):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

# -*- coding: utf-8 -*-
N = int(input())
L = list(map(int, input().split()))
if max(L) < (sum(L)-max(L)):
    print("Yes")
else:
    print("No")
n = int(input())
w = list(map(int,input().split()))

m=[]
for i in range(1,n):
    m.append(sum(:i) - sum(i:))
print(min(m))

### FIXED CODE ###

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

accum = 0
ans = 10000
before = 10000
for i in range(n):
    accum += w[i]
    sa = abs(sum(w) - (accum*2))
    if sa < ans:
        ans = sa

print(ans)
N = int(input())
S = list(map(int,input().split()))

col_list = [399,799,1199,1599,1999,2399,2799,3199]
count_list = [0]*(len(col_list)+1)

for i in range(N):
    for j in range(len(col_list)+1):
        if j == len(col_list):
            if 3200<=S[i]:
                count_list[j] = count_list[j] + 1
        elif S[i]<=col_list[j]:
            count_list[j] = count_list[j]+1
            break

ans = 0
for i in range(len(col_list)):

    if count_list[i] != 0:
        ans += 1
print(str(max(1,ans)) + ' ' + str(ans+count_list[-1]))

　　

### FIXED CODE ###

N = int(input())
S = list(map(int,input().split()))

col_list = [399,799,1199,1599,1999,2399,2799,3199]
count_list = [0]*(len(col_list)+1)

for i in range(N):
    for j in range(len(col_list)+1):
        if j == len(col_list):
            if 3200<=S[i]:
                count_list[j] = count_list[j] + 1
        elif S[i]<=col_list[j]:
            count_list[j] = count_list[j]+1
            break

ans = 0
for i in range(len(col_list)):

    if count_list[i] != 0:
        ans += 1
print(str(max(ans,1)) + ' ' + str(ans+count_list[-1]))
#B
N=int(input())
cnt=0
flag=False
for i in range(N):
    a,b=map(int,input().split())
    if a==b:
        cnt+=1
    else:
        cnt=0
    if cnt=3:
        flag=True
        break
if flag:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

#B
N=int(input())
cnt=0
flag=False
for i in range(N):
    a,b=map(int,input().split())
    if a==b:
        cnt+=1
    else:
        cnt=0
    if cnt==3:
        flag=True
        break
if flag:
    print("Yes")
else:
    print("No")
s = list(input())
t = list(input())
n=0
for i in range(len(s)):
    if s[i]!=t[i]:
        
        n+=1
print(n)

### FIXED CODE ###

a = int(input())
print(a+a**2 +a**3)
import sys
import math

line = []
for l in sys.stdin:
    for i in l.split(' '):
    	line.append(float(i))
a = (line[0]-line[2])**2+(line[1]-line[3])**2
b = math.sqrt(a)
print ('%.10f' % b)

### FIXED CODE ###

import math

x1,y1,x2,y2 = map(float,raw_input().split())
a = math.sqrt((x1-x2)**2+(y1-y2)**2)
print '%f'%a
n,q = map(int,input().split())

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

counter = [0 for i in range(n)]
for i in range(q):
    p,x = map(int,input().split())
    counter[p-1] += x

def dfs(now,prev):
    for next in edges[now]:
        if next == prev:
            continue
        counter[next] += counter[now]
        dfs(next,now)

dfs(0,-1)
print(*counter)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 6)

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

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

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

def dfs(now,prev):
    for next in edges[now]:
        if next == prev:
            continue
        counter[next] += counter[now]
        dfs(next,now)

dfs(0,-1)
print(*counter)
import math
import sys
sys.setrecursionlimit(10000000)

n = int(input())
s = int(input())

up = math.sqrt(n)

def colsum(num, base):
    if num < base:
        return num
    else:
        return num%base + colsum(num//base,base)

#s = n(n<b)
if s == n:
    print(n+1)
    exit()


#sqrt(n)まで探索
for i in range(2,int(up)+1):
    if s == colsum(n,i):
        print(i)
        exit()

#2桁しかあり得ない場合(sqrt(n)<b<n)
for j in range(1,int(up)+1):
    if (n-s)%j == 0:
        b = (n-s)/j + 1
        if s == colsum(n,b) and b > 1:
            print(i)
            exit()

print(-1)

### FIXED CODE ###

import math
import sys

n = int(input())
s = int(input())

up = math.sqrt(n)

def colsum(num, base):
    if num < base:
        return num
    else:
        return num%base + colsum(num//base,base)

#s >= n
if s == n:
    print(n+1)
elif s > n:
    print(-1)
else:
    #sqrt(n)まで探索
    for i in range(2,int(up)+1):
        if colsum(n,i) == s:
            print(i)
            sys.exit()

    #2桁しかあり得ない場合(sqrt(n)<b<n)
    for j in range(int(up),0,-1):
        if (n-s)%j == 0:
            b = (n-s)/j + 1
            if colsum(n,b) == s and b > 1:
                print(int(b))
                sys.exit()

    print(-1)
X, N = map(int, input().split())
p = list(map(int, input().split()))
for d in range(X + 1):
    for s in [-1, +1]:
            a = X + s * d
			if p.count(a) == 0:
				print(a)
				exit(0)


### FIXED CODE ###

x1,x2,x3,x4,x5=map(int,input().split())
a=[]
a.append(x1)
a.append(x2)
a.append(x3)
a.append(x4)
a.append(x5)
for i in range(5):
    if a[i]==0:
        print(i+1)
l=list(input())
l[5]=""
l[12]=""
print(sum(l))

### FIXED CODE ###

l=list(input())
l[13]=" "
l[5]=" "
print("".join(l))