Harryxun/stf_run huggingface dataset:
S = input()
first = S[0]
inverse = str(1-int(first))
unit = first+inverse
if len(S) % 2 == 0:
  sample = unit*len(S)//2
else:
  sample = unit*len(S)//2+first

count = 0
for k in range(len(S)):
  if S[k] != sample[k]:
    count += 1

print(count)


### FIXED CODE ###

S = input()
first = S[0]
inverse = str(1-int(first))
unit = first+inverse
if len(S) % 2 == 0:
  sample = unit*(len(S)//2)
else:
  sample = unit*(len(S)//2)+first

count = 0
for k in range(len(S)):
  if S[k] != sample[k]:
    count += 1

print(count)
x=[]
n=int(input())
for i in range(0,n):
    xa=int(input())
    x.append(xa)
count=0
for i in range(0,n-2):
    for j in range(i,n-1):
        if(x[i]==x[j]):
            continue
        for k in range(j,n):
            if((x[i]==x[k])or(x[j]==x[k])):
                continue
            if ((x[i]+x[j]>x[k])and(x[i]+x[k]>x[j])and(x[j]+x[k]>x[i])):
                count+=1
print(count)

### FIXED CODE ###

n = int(input().strip())
x = list(map(int, input().strip().split()))
count=0
for i in range(0,n-2):
    for j in range(i,n-1):
        if(x[i]==x[j]):
            continue
        for k in range(j,n):
            if((x[i]==x[k])or(x[j]==x[k])):
                continue
            if ((x[i]+x[j]>x[k])and(x[i]+x[k]>x[j])and(x[j]+x[k]>x[i])):
                count+=1
print(count)
A,B=map(int,input().split())
if (A+B)%2 !=0:
	print("IMPOSSIBLE")
else:
	print((A+B)2)

### FIXED CODE ###

A,B=map(int,input().split())
if (A+B)%2 !=0:
    print("IMPOSSIBLE")
else:
    print(int((A+B)/2))
import sys
s = input()
t = input()

for i in range(len(s)):
    if s == t:
        print("Yes")
        sys.exit()
    else:
        tmp = s[0]
        del s[0]
        s = s + tmp
print("No")

### FIXED CODE ###

import sys
s = input()
t = input()

for i in range(len(s)):
    if s == t:
        print("Yes")
        sys.exit()
    else:
        tmp = s[0]
        s = s[1:] + tmp
print("No")
n=int(input())
l=list(map(int,input().split())
sum_m=0
for i in l:
	sum_m+=1/i
print(1/sum_m)


### FIXED CODE ###

n=int(input())
l=list(map(int,input().split()))
sum_m=0
for i in l:
	sum_m+=1/i
print(1/sum_m)
import sys
a, b, c = int(sys.stdin.readline().split())

print(c, a, b)

### FIXED CODE ###

import sys
a, b, c = map(int, sys.stdin.readline().split())

print(c, a, b)
import sys
import fractions
input = sys.stdin.readline

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

n = fractions.gcd(A, B)
if n == 1:
    print(1)
    sys.exit()


def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]


p = set(primes(n))
count = sum([1 for i in p if not n % i])

print(count + 1)


### FIXED CODE ###

import sys
import fractions
input = sys.stdin.readline

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

n = fractions.gcd(A, B)
if n == 1:
    print(1)
    sys.exit()


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

    if temp != 1:
        arr.append([temp, 1])

    if arr == []:
        arr.append([n, 1])

    return arr


a = {x[0] for x in factorization(A)}
b = {x[0] for x in factorization(B)}

print(len(a & b) + 1)
N = int(input())
T = list(map(int,input().split()))
M = int(input())
d = [list(map(int,input().split())) for i in range(M)]
time = sum(T)
for i in range(len(d)):
    time += d[i][0] - T[d[i][1]-1]
print(time)

### FIXED CODE ###

N = int(input())
T = list(map(int,input().split()))
M = int(input())
d = [list(map(int,input().split())) for i in range(M)]
t = sum(T)
for i in range(len(d)):
    time = t + d[i][1] - T[d[i][0]-1]
    print(time)
a,b=map(int,input().split())
if b==2:
    a=bin(a)
elif b==8:
    a=oct(a)
elif b==10:
    a=int(a)
print(len(a))

### FIXED CODE ###

a,b=map(int,input().split())
count=1
while a>=b:
    a=a/b
    count+=1
print(count)
A = list(input().split(" "))
N = int(A[0])
K = int(A[1])
H = list(input().split(" "))
sum = 0
H.sort()
for i in range(K):
    H[N-1-i] = "0"
for i in range(N):
    sum += int(H[i])
print(sum)

### FIXED CODE ###

n,k = map(int,input().split())
H = list(map(int,input().split()))
H.sort(reverse = True)
H = H[k:]
print(sum(H))
n,a,b=map(int, input().split())
s=list(map(input().split()))
num=0
s_b=[i for i,x in s if x=='b']
for i in range(n):
  if s[i]=='c':
    print('No')
  elif s[i]=='a':
    if i <=(a+b):
      num+=1
      print('Yes')
    else:
      print('No')
  else:
    if s_b.index(i)<=b:
      num+=1
      print('Yes')
    else:
      print('No')   
  if num==a+b:
    break
    

### FIXED CODE ###

n,a,b=map(int, input().split())
s=list(input())
num=0
num_f=0
qual=[]
for i in range(n):
  if num<a+b:
    if s[i]=='a':
      num+=1
      qual.append('Yes')     
    elif s[i]=='b' and num_f<b:
      num+=1
      num_f+=1
      qual.append('Yes')
    else:
      qual.append('No')   
  else:
    qual.append('No')
for i in range(n):
  print(qual[i])
H,W = map(int,input().split())
s = [list(input()) for _ in range(H)]
black=0

for tate in s:
  for yoko in tate:
    if yoko=="#":
      black += 1

def search(y,x,H,W,s):
  child=[]
  if y<H-1:
    if s[y+1][x]==".":
      child.append([y+1,x])
  if 0<y:
    if s[y-1][x]==".":
      child.append([y-1,x])
  if 0<x:
    if s[y][x-1]==".":
      child.append([y,x-1])
  if x<W-1:
    if s[y][x+1]==".":
      child.append([y,x+1])
  return child

def dfs(y,x,cnt,H,W,s):
  node_to_visit=search(y,x,H,W,s)
  flag=True
  
  while flag:
    cnt += 1
    tmp=[]
    tmp2=[]
    for next_point in node_to_visit:
      t=next_point[0]
      u=next_point[1]
      if t!= y or u!=x:
        tmp=search(u,t,H,W,s)
      tmp2 += tmp
    node_to_visit=tmp2
    if [H-1,W-1] in node_to_visit:
      white=cnt
      flag=False
      break
      
  ans=H*W-white-black-2
  print(white,black,ans)

  
dfs(0,0,0,H,W,s)

### FIXED CODE ###

from collections import deque

H,W = map(int,input().split())
s = [list(input()) for _ in range(H)]
c = [[-1 for _ in range(W)] for _ in range(H)]

black=0
for tate in s:
  for yoko in tate:
    if yoko=="#":
      black += 1

def search(y,x,H,W,c,i):
  child=[]      
  if y<H-1:
    if s[y+1][x]=="." and c[y+1][x]==-1:
      c[y+1][x]=i
      child.append([y+1,x])
  if 0<y:
    if s[y-1][x]=="." and c[y-1][x]==-1:
      c[y-1][x]=i
      child.append([y-1,x])
  if 0<x:
    if s[y][x-1]=="." and c[y][x-1]==-1:
      c[y][x-1]=i
      child.append([y,x-1])
  if x<W-1:
    if s[y][x+1]=="." and c[y][x+1]==-1:
      c[y][x+1]=i
      child.append([y,x+1])
  return child

def dfs(y,x,c):
  visited=[[y,x]]
  c[y][x]=0
  i=1
  
  while visited:
    tmp=[]
    for a in visited:
      p=search(a[0],a[1],H,W,c,i)  #listが戻る
      tmp += p
    visited=tmp
    i += 1

dfs(0,0,c)
a=c[-1][-1]
if a==-1:
  print(-1)
else:
  print(H*W-black-a-1)
A,B = map(int.input(),split())
print(A * B)

### FIXED CODE ###

A,B = map(int,input().split())
print(A * B)
from numba import njit
import numpy as np


def main(N, P):
    lista = [1, -1, N, -N]
    d = np.zeros((N, N), dtype=np.int32)
    d = d.ravel()
    sit = np.ones_like(d)
    stack = np.empty_like(d)
    count = 0
    for i in range(N*N):
        d[i] = min(i % N, (N-1-i) % N, i//N, N-1-i//N)
    for player in P:
        sit[player-1] = 0
        count += d[player-1]
        stack[0] = player
        num = 0
        while num >= 0:
            p = stack[num]
            num -= 1
            a = d[p-1]+sit[p-1]
            for i in lista:
                if p+i < 1 or p + i > N*N:
                    continue
                if d[p+i-1] > a:
                    d[p+i-1] = a
                    num += 1
                    stack[num] = p+i
    print(count)


def cc_export():
    from numba.pycc import CC
    cc = CC('my_module')
    cc.export('main', '(i8,i8[:])')(main)
    cc.compile()


if __name__ == '__main__':
    import sys
    if sys.argv[-1] == 'ONLINE_JUDGE':
        cc_export()
        exit(0)
    from my_module import main
    N = int(input())
    P = np.array(input().split(), np.int32)
    #N = 500
    #P = [(i+4000) % N*N for i in range(N*N)]
    main(N, P)


### FIXED CODE ###

from numba import njit
import numpy as np

@njit
def main(N, P):
    lista = [1, -1, N, -N]
    d = np.zeros((N, N), dtype=np.int32)
    d = d.ravel()
    sit = np.ones_like(d)
    stack = np.empty_like(d)
    count = 0
    for i in range(N*N):
        d[i] = min(i % N, (N-1-i) % N, i//N, N-1-i//N)
    for player in P:
        sit[player-1] = 0
        count += d[player-1]
        stack[0] = player
        num = 0
        while num >= 0:
            p = stack[num]
            num -= 1
            a = d[p-1]+sit[p-1]
            for i in lista:
                if p+i < 1 or p + i > N*N:
                    continue
                if d[p+i-1] > a:
                    d[p+i-1] = a
                    num += 1
                    stack[num] = p+i
    print(count)

N = int(input())
P = np.array(input().split(), np.int32)

main(N, P)
X = int(input())
Y = int(input())
statement = False
for a in range(X+1):
  for b in range(X-a+1):
    for c in range(X-a-b+1):
      if (a * 10000 + b * 5000 + c * 1000 == Y) and (a + b + c == X):
        print(str(a) + " " + str(b) + " " + str(c))
        statement = True
if not statement:
  print("-1 -1 -1")

### FIXED CODE ###

X, Y = map(int, input().split())
statement = False
for a in range(X+1):
  for b in range(X-a+1):
    c = X - a - b
    if a * 10000 + b * 5000 + c * 1000 == Y:
      print(str(a) + " " + str(b) + " " + str(c))
      statement = True
      break
  if statement:
    break
if not statement:
  print("-1 -1 -1")
a, b, c = sorted(map(int, input().split()))
diff = c - b
newa = a + diff
if (c - newa) % 2 == 0:
	print(d + (c - newa) // 2)
else:
	print(d + (c - newa + 3) // 2)

### FIXED CODE ###

S = list(map(int, input().split()))
M = max(S)
r = sum(M - i for i in S)
print((r + 3 * (r % 2)) // 2)
# coding: utf-8

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

powof2 = lambda x: len("{:b}".format(x))

def f2(n, h, a):
    p = powof2(n)
    N = 2 ** p
    segt = [0] * (2 * N - 1)

    def getmax(a, b, i = 0, l = 0, r = N - 1):
        if r <= a or b <= l:
            return(0)
        if a <= l and r <= b:
            return(segt[i])
        lmax = getmax(a, b, 2 * i + 1, l, (l + r) // 2)
        rmax = getmax(a, b, 2 * i + 2, (l + r) // 2, r)
        return(lmax if lmax > rmax else rmax)

    def setmax(i, v):
        si = i + N - 1
        segt[si] = v
        while si > 0:
            si = (si - 1) // 2
            si1 = 2 * si + 1
            si2 += 1
            segt[si] = segt[si1] if segt[si1] > segt[si2] else segt[si2]

    for i in range(1, n + 1):
        m = getmax(0, h[i])
        setmax(h[i], m + a[i])

    return(getmax(0, n))

n = int(input()) # 1 <= n <= 2 x 10^5
h = [0] + list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
print(f2(n, h, a))


### FIXED CODE ###

# coding: utf-8

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

powof2 = lambda x: len("{:b}".format(x))

def f2(n, h, a):
    p = powof2(n)
    N = 2 ** p
    segt = [0] * (2 * N - 1)

    def getmax(a, b, i = 0, l = 0, r = N - 1):
        if r <= a or b <= l:
            return(0)
        if a <= l and r <= b:
            return(segt[i])
        i1 = 2 * i + 1
        i2 = i1 + 1
        lr = (l + r) // 2
        lmax = getmax(a, b, i1, l, lr)
        rmax = getmax(a, b, i2, lr, r)
        return(lmax if lmax > rmax else rmax)

    def setmax(i, v):
        si = i + N - 1
        segt[si] = v
        while si > 0:
            si = (si - 1) // 2
            si1 = 2 * si + 1
            si2 = si1 + 1
            segt[si] = segt[si1] if segt[si1] > segt[si2] else segt[si2]

    for i in range(1, n + 1):
        m = getmax(0, h[i])
        setmax(h[i], m + a[i])

    return(getmax(0, n))

n = int(input()) # 1 <= n <= 2 x 10^5
h = [0] + list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
print(f2(n, h, a))
a = int(input())
s = input()
if a >= 3200:
  print("s")
  else:
    print("red")

### FIXED CODE ###

a = int(input())
s = input()
if a >= 3200:
  print(s)
else:
  print("red")
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

N, S = [int(input()), int(input())]


def solve1():
    i = 2
    while i * i <= N:
        s, n = 0, N
        while n > 0:
            s += n % i
            n //= i
        if s == S:
            return i

        i += 1

    return 1 << 60


def solve2():
    i = 1
    ret = 1 << 60
    while i * i <= N:
        b = (N - S) // i + 1
        s, n = 0, N
        while n > 0:
            s += n % b
            n //= b
        if s == S:
            ret = min(ret, b)
        i += 1

    return ret


def solve():
    ret = min(solve1(), solve2())
    return ret if ret != 1 << 60 else -1


print(solve())


### FIXED CODE ###

import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

N, S = [int(input()), int(input())]


def solve1():
    i = 2
    while i * i <= N:
        if ok(i, N, S):
            return i

        i += 1

    return 1 << 60


def solve2():
    i = 1
    ret = 1 << 60
    while i * i <= N:
        b = (N - S) // i + 1
        if ok(b, N, S):
            ret = min(ret, b)
        i += 1

    return ret


def ok(b, N, S):
    if b <= 1:
        return False

    s, n = 0, N
    while n > 0:
        s += n % b
        n //= b

    return s == S



def solve():
    if S == N:
        return N + 1
    ret = min(solve1(), solve2())
    return ret if ret != 1 << 60 else -1


print(solve())
N = int(input())
a = [int(i) for i in input().split()]


s = sum(a)
m = s - a[:1]
print(m)
for i in range(2, N):
    b = sum(a[:i])
    c = s - b
    #print(b)
    #print(c)
    if m > (abs(b-c)):
        m = abs(b-c)
    else:
        break
print(m)

### FIXED CODE ###

N = int(input())
a = [int(i) for i in input().split()]


s = sum(a)
m = pow(10, 20)
b = 0
for i in range(N-1):
    b += a[i]
    c = s - b
    #print(b)
    #print(c)
    if m > (abs(b-c)):
        m = abs(b-c)
    #print(a[i])
print(m)
def hantei(x):
    

N = int(input())
if N >= 105:
    print(1)
else:
    print(0)    

### FIXED CODE ###

N = int(input())
ans = 0
for i in range(N + 1):
    if i % 2 == 0:
        continue
    c = 0
    for j in range(1, i + 1):
        if i % j == 0:
            c += 1
    if c == 8:
        ans += 1
print(ans)
N = int (input ())
l = input ().split ()
list.sort (l, reverse=True)
a = 0
x = 0
for i in range (round(N/2)):
    x += l[a]
    a += 2
a = 1
y = 0
for i in range (N-(round(N/2))):
    y += l[a]
    a += 2
print (x-y)

### FIXED CODE ###

N = int (input ())
L = input ().split ()
l = [int(s) for s in L]
list.sort (l, reverse=True)
a = 0
x = 0
y = 0
while True:
    x += int (l[a])
    a += 1
    if a == N:
        break
    y += int (l[a])
    a += 1
    if a == N:
        break
print (x-y)
import math
 
s=list(map(int,input().split()))
t=list(map(int,input().split()))
a=0
t.sort(reverse=True)
for i in range(s[1]):
  t[0]=math.floor(t[0]/2)
  if s[1]>=2:
    if t[0]<t[1]:
      t.sort(reverse=True)
  else:
    continue
a=sum(t)
print(a)

### FIXED CODE ###

import math
 
s=list(map(int,input().split()))
t=list(map(int,input().split()))
a=0
b=0
c=0
d=s[1]
t.sort(reverse=True)
if s[0]==1:
  for i in range(s[1]):
    t[0]=math.floor(t[0]/2)
else:
  c=t[0]/2
  for j in range(s[1]):
    for l in range(s[0]):
      if d>0:
        if c<t[l]:
          t[l]=math.floor(t[l]/2)
          d=d-1
        else:
            t.sort(reverse=True)
            c=t[0]/2
            break
      else:
        break
e=sum(t)
print(e)
s = sorted(raw_input())
t = sroted(raw_input())[::-1]
print "Yes" if s < t else "No"

### FIXED CODE ###

s = sorted(raw_input())
t = sorted(raw_input())[::-1]
print "Yes" if s < t else "No"
n,q=map(int,input().split())
s=input()
td=[list(input().split()) for _ in range(q)]


def bichk(x,flg):
  now=[x,s[x]]
  for t,d in td:
    if t==now[1]:
      if d=='L':
        x-=1
        if x<0 and flg:return False
        now=[x,s[x]]
      else:
        x+=1
        if x>n-1 and not flg:return False
        now=[x,s[x]]
  return True
l,r=0,n
# 左から落ちないゴーレムの最小座標
while r-l>1:
  x=(l+r)//2
  if bichk(x,True):
    l,r=l,x
  else:
    l,r=x,r
l0=l if bichk(l,True) else r

l,r=0,n
# 右から落ちないゴーレムの最大座標
while r-l>1:
  x=(l+r)//2
  if bichk(x,False):
    l,r=x,r
  else:
    l,r=l,x
r0=r if r<n and bichk(r,False) else l

print(max(0,r0-l0+1))

### FIXED CODE ###

n,q=map(int,input().split())
s=input()
td=[list(input().split()) for _ in range(q)]
def func0(x):
  # はじめx(0-indexed)にいるゴーレムが0から左にいき消滅するか
  for t,d in td:
    if t==s[x]:
      if d=='R':x+=1
      if d=='L':x-=1
    if x<0:return True
    if x>n-1:return False
  return False
def funcN(x):
  # はじめx(0-indexed)にいるゴーレムがn-1から右にいき消滅するか
  for t,d in td:
    if t==s[x]:
      if d=='R':x+=1
      if d=='L':x-=1
    if x<0:return False
    if x>n-1:return True
  return False

l,r=-1,n
while r-l>1:
  x=(l+r)//2
  if func0(x):
    l,r=x,r
  else:
    l,r=l,x
a=l
l,r=-1,n
while r-l>1:
  x=(l+r)//2
  if funcN(x):
    l,r=l,x
  else:
    l,r=x,r
b=r
print(n-(a+1)-(n-b))
n = int(input())

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

sosu = make_divisors(n)
#print(type(sosu))
kumi = []
for i in range(len(sosu)):
  for j in range(len(sosu)):
    #print(type(sosu[i]))
    if sosu[i]*sosu[j] == n:
      kumi.append([str(sosu[i]), str(sosu[j])])
if len(kumi)%2 == 0:
  print(len(min(kumi[len(kumi)/2])))
else:
  print(len(min(kumi[round(len(kumi)/2)])))
      



### FIXED CODE ###

n = int(input())

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

sosu = make_divisors(n)
#print(type(sosu))
kumi = []
for i in range(len(sosu)):
  for j in range(len(sosu)):
    #print(type(sosu[i]))
    if sosu[i]*sosu[j] == n:
      kumi.append([str(sosu[i]), str(sosu[j])])
#print(kumi)
top = 10000000000
#iter = 0
#if 
for i in kumi[:int(len(kumi)/2)+2]:
  sums = max(len(i[0]), len(i[1]))
  if top > sums:
    top = sums
    #iter = max(len(kumi[0]), len(kumi[1]))
print(top)
N=int(input())
A=[]
for i in range(N):
  tmp=float(input())*10**9
  A.append(int(tmp))

dat=[[0]*19 for _ in range(19)]  
rui=[[0]*19 for _ in range(19)]

B=[]

for i in range(N):
  dev2,dev5=0,0
  while A[i]%2==0:
    dev2+=1
    A[i]//=2
  while A[i]%5==0:
    dev5+=1
    A[i]//=5
  dat[dev2][dev5]+=1
  B.append([dev2,dev5])
  
for i in range(19):
  for j in range(19):
    for k in range(i+1):
      for l in range(j+1):
        rui[k][l]+=dat[i][j]
  
ans=0
for i in range(N):
  dev2,dev5=B[i]
  t_dev2,t_dev5=18-dev2,18-dev5
  if dev2>=t_dev2 and dev5>=t_dev5:
    ans-=1
  ans+=rui[t_dev2][t_dev5]

print(ans//2)
  
  
    
    

### FIXED CODE ###

N=int(input())
A=[]
for i in range(N):
  #tmp=float(input())*10**9
  inp=input()
  ten=inp.find(".")
  L=len(inp)
  batu=9
  if ten!=-1:
    batu-=L-ten-1
  inp=inp.replace(".","")
  inp=int(inp)
  inp*=10**batu
  A.append(inp)

#print(A)

dat=[[0]*19 for _ in range(19)]  
rui=[[0]*19 for _ in range(19)]

B=[]

for i in range(N):
  dev2,dev5=0,0
  while A[i]%2==0 and dev2<18:
    dev2+=1
    A[i]//=2
  while A[i]%5==0 and dev5<18:
    dev5+=1
    A[i]//=5
  dat[dev2][dev5]+=1
  B.append([dev2,dev5])
  
for i in range(19):
  for j in range(19):
    for k in range(i+1):
      for l in range(j+1):
        rui[k][l]+=dat[i][j]
  
ans=0
for i in range(N):
  dev2,dev5=B[i]
  t_dev2,t_dev5=18-dev2,18-dev5
  if dev2>=t_dev2 and dev5>=t_dev5:
    ans-=1
  ans+=rui[t_dev2][t_dev5]

print(ans//2)
S = list(input())
T = list(input())
dic = {}
for i in range(len(S)):
    if i == 0:
        dic[S[i]] = T[i]
        dic[T[i]] = S[i]
        S[i] = T[i]
    else:
        if T[i] in S[:i]:
            if dic[S[i]] != T[i]:
                print('No')
                exit()
        else:
            dic[S[i]] = T[i]
            dic[T[i]] = S[i]
            S[i] = T[i]
print('Yes')


### FIXED CODE ###

S = input()
T = input()
dict1 = {}
dict2 = {}

for s,t in zip(S,T):
    if s in dict1:
        if dict1[s] == t:
            pass
        else:
            print('No')
            exit()
    else:
        dict1[s] = t
    if t in dict2:
        if dict2[t] == s:
            pass
        else:
            print('No')
            exit()
    else:
        dict2[t] = s
print('Yes')
if d >= abs(a - c) or (d >= abs(a - b) and d >= abs(b - c)):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

a, b, c, d = map(int, input().split())
if d >= abs(a - c) or (d >= abs(a - b) and d >= abs(b - c)):
    print('Yes')
else:
    print('No')
from itertools import accumulate
import sys
input = sys.stdin.readline

n,c = map(int,input().split())
x1,v1 = [0],[0]
x2,v2 = [],[]
for _ in range(n):
  a,b = map(int, input().split())
  x1.append(a)
  x2 = [c-a] + x2
  v1.append(b)
  v2 = [b] + v2
x2 = [0] + x2
v2 = [0] + v2

v1, v2 = list(accumulate(v1)), list(accumulate(v2))

f1 = [v1[i] - x1[i] for i in range(n+1)]
f2 = [v2[i] - x2[i] for i in range(n+1)]
g1,x1_ = f1[0],x1[0]
g2,x2_ = f2[0],x2[0]
val = max(v1[n]-x1[n] + g2 - min(x1[n],x2_), v2[n]-x2[n] + g1 - min(x2[n],x1_))
for i in range(1,n+1):
  if g1<f1[i]:
	  g1,x1_ = f1[i], x1[i]
  if g2<f2[i]:
	  g2,x2_ = f2[i], x2[i]
  val = max(val, v1[n-i]-x1[n-i] + g2 - min(x1[n-i],x2_), v2[n-i]-x2[n-i] + g1 - min(x2[n-i],x1_))

print(val)

### FIXED CODE ###

s = input()
print(700+100*sum([1 for x in s if x=='o']))
n,y = map(int,input().split())
count = 0
for a in range(2001):
  for b in range(2001):
    c = n - a - b
    if 10000*a + 5000*b + 1000*c == y and 0 <= c <= 2000:
      print(str(a) + " " + str(b) + " " + str(c))
      count += 1
      break
  if count == 1:
    break
if count == 1:
  break

### FIXED CODE ###

n,y = map(int,input().split())
kekkas = []
for a in range(2001):
  for b in range(2001):
    kekka = 9000*a + 4000*b - (y - 1000*n)
    if kekka == 0:
      c = n - a - b
      if c >= 0:
        kekkas.append((a,b,c))
if len(kekkas) > 0 :
  print(str(kekkas[0][0]) + " " + str(kekkas[0][1]) + " " + str(kekkas[0][2]))
else:
  print("-1 -1 -1")
A, V = map(int, input().split())
B, W = map(int, input().split())
T = input()

a = A #+ (int(V) * int(T))
b = B #+ (int(W) * int(T))

for i in range(1, T + 1, 1):
    a += V
    b += W

    if a == b:
        print("YES")
        break

if (a != b):
    print("NO")

### FIXED CODE ###

a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())

if abs(a-b) <= t* (v-w):
    print('YES')
else:
    print('NO')
i = list(map(int,input().split()))
l = list(map(int,input().split()))
n = i[0]
x = i[1]

d = 0
count = 0
j = 0

while (d <= x) and (j <= len(l)):
  count = count + 1
  d = d + l[j]
  j = j + 1
  

if count < n+1:
  print(count)
else:
  print(n+1)


### FIXED CODE ###

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

d = 0
count = 0

for i in range(len(l)):
  if d <= x:
  	d = d + l[i]
  	count = count + 1
  
if d <= x:
  count += 1
  
print(count)
sx,sy,tx,ty = map(int,input().split())
ans = ["U"]*(ty-sy) + ["R"]*(tx-sx) + ["D"]*(ty-sy) + ["L"]*(tx-sx+1) + ["U"]*(ty-sy+1) + ["R"]*(tx-sx+1) + ["D"] + ["R"] + ["D"]*(ty-sy+1) + ["L"]*(tx-sx+1) + ["U"]
print("".join(ans))

### FIXED CODE ###

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