Harryxun/stf_run huggingface dataset:
S = input()

def palind(word):
  word = word.lower()
  return word[::-1] ==word

S_inv = palind(S)
out = 0
for i in S:
  if S[i] ! S_inv[i]:
    out = out + 1

print(out)
    

### FIXED CODE ###

S = input()
S_inv = S[::-1]

out = 0
for i in range(len(S)):
  if S[i] != S_inv[i]:
    out = out + 1

out = out // 2
#if out % 2 == 1:
#  out == out // 2 + 1
#else:
#  out == out // 2 
print(out)
# -*- coding: utf-8 -*-
A=int(input())
B=int(input())
if A==1:
    if B==2:
        C=3
    if B==3:
        C=2
if A==2:
    if B==1:
        C=3
    if B==3:
        C=1
if A==3:
    if B==1:
        C==2
    if B==2:
        C==1

print(C)

### FIXED CODE ###

# -*- coding: utf-8 -*-
A=int(input())
B=int(input())
if A==1:
    if B==2:
        C=3
    if B==3:
        C=2
if A==2:
    if B==1:
        C=3
    if B==3:
        C=1
if A==3:
    if B==1:
        C=2
    if B==2:
        C=1

print(C)
print {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}[input().strip()]

### FIXED CODE ###

print {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}[raw_input().strip()]
a, b, c = map(int, raw_input().split())
k = 0
      
for i in range(a, b):
   if c % i == 0 and != b:
      k += 1
   elif a == b and b == c:
      k = 1
 
print k

### FIXED CODE ###

a, b, c = map(int, raw_input().split())
k = 0
      
for i in range(a, b+1):
   if c % i == 0:
      k += 1
 
print k
x=int(input())

for i in range(2,int(x**0.5)+1):
  if x%i==0:
    q=i
    #print(q)
    break

for i in range(-100000,100000):
  if (i+q)**5-i**5==x:
    break
print(i+q,i)

### FIXED CODE ###

x=int(input())
for i in range(-200,200):
  for j in range(-200,200):
    if i**5-j**5==x:
      a=i
      b=j
print(a,b)
n = int(input())
ans = 10**9
def digitSum(n):
    # 数値を文字列に変換
    s = str(n)
    # １文字ずつ数値化し配列にする。
    array = list(map(int, s))
    # 合計値を返す
    return sum(array)
for a in range(1,n//2+3):
    b = n-a
    
    ans = min(digitSum(a)+digitSum(b),ans)
print(ans)

### FIXED CODE ###

n = int(input())
ans = 10**9
def digitSum(n):
    # 数値を文字列に変換
    s = str(n)
    # １文字ずつ数値化し配列にする。
    array = list(map(int, s))
    # 合計値を返す
    return sum(array)
for a in range(1,n//2+3):
    b = n-a
    if a>=1 and b>=1:
        
        ans = min(digitSum(a)+digitSum(b),ans)
print(ans)
i = 1
while 1:
  n = input()
  if n == 0:
    break
  print "Case %d: %d" % (i,n):
  i = i + 1

### FIXED CODE ###

i = 1
while(1):
  x = int(raw_input())
  if x == 0:
    break
  print "Case %d: %d" %(i,x)
  i = i + 1
def merge(A, left, mid, right):

    n1 = mid-left
    n2 = right-mid
    L = [0 for i in range(n1+1)]
    R = [0 for i in range(n2+1)]
    for i in range(n1):
        L[i] = A[left+i]
    for i in range(n2):
        R[i] = A[mid+i]
    L[n1] = 100000001
    R[n2] = 100000001
    i = 0
    j = 0
    #global cnt
    cnt = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i = i+1
            cnt +=1
        else:
            A[k] = R[j]
            j = j+1
            cnt +=1
    return cnt

def mergeSort(A, left, right):
    if left+1 < right:
         mid = (left+right) // 2
         cnt1 = mergeSort(A, left, mid)
         cnt2 = mergeSort(A, mid, right)
         cnt3 = merge(A, left, mid, right)
         return cnt1+cnt2+cnt3
    else:
        return 0

n = input()
A = list(map(int, input().split()))
cnt = mergeSort(A, 0, len(A))
print(*A)
print(str(cnt))

### FIXED CODE ###

def merge(A, left, mid, right):

    n1 = mid-left
    n2 = right-mid
    #L = [0 for i in range(n1+1)]
    #R = [0 for i in range(n2+1)]
    #for i in range(n1):
    #    L[i] = A[left+i]
    #for i in range(n2):
    #    R[i] = A[mid+i]
    L = A[left:mid]
    R = A[mid:right]
    L.append(float('inf'))
    R.append(float('inf'))
    i = 0
    j = 0
    global cnt

    for k in range(left, right):
        cnt += 1
        if L[i] <= R[j]:
            A[k] = L[i]
            i = i+1
        
        else:
            A[k] = R[j]
            j = j+1
    return cnt

def mergeSort(A, left, right):
    if left+1 < right:
         mid = (left+right) // 2
         mergeSort(A, left, mid)
         mergeSort(A, mid, right)
         merge(A, left, mid, right)
    else:
        return 0

n = input()
A = list(map(int, input().split()))
cnt = 0
mergeSort(A, 0, len(A))
print(*A)
print(str(cnt))
n, k = map(int,input().split())
if n % k ==0:
    ans =0
else :
    ans =1
    
prnt(ans)

### FIXED CODE ###


n, k = map(int,input().split())
if n % k ==0:
    ans =0
else :
    ans =1
    
print(ans)
N,A,B,C = map(int,input().split())
l = [input() for i in range(N)]
INF = 10 ** 9

def ans(cur,a,b,c):
    
    if cur == N:
        return abs(a-A) + abs(b-B) + abs(c-C) - 30 if min(a,b,c) > 0 else INF
    
    ret0 = ans(cur + 1,a,b,c) 
    ret1 = ans(cur + 1,a + l[cur],b,c) + 10
    ret2 = ans(cur + 1,a,b + l[cur],c) + 10
    ret3 = ans(cur + 1,a,b,c + l[cur]) + 10

    return min(ret0,ret1,ret2,ret3)

print(ans(0,0,0,0))







### FIXED CODE ###

N,A,B,C = map(int,input().split())
l = [int(input()) for i in range(N)]
INF = 10 ** 9

def ans(cur,a,b,c):
    
    if cur == N:
        return abs(a-A) + abs(b-B) + abs(c-C) - 30 if min(a,b,c) > 0 else INF
    
    ret0 = ans(cur + 1,a,b,c) 
    ret1 = ans(cur + 1,a + l[cur],b,c) + 10
    ret2 = ans(cur + 1,a,b + l[cur],c) + 10
    ret3 = ans(cur + 1,a,b,c + l[cur]) + 10

    return min(ret0,ret1,ret2,ret3)

print(ans(0,0,0,0))
p = 0
a,b,c = map(int,input().split())
for (int x = a; x <= b; x++):
    if c%x==0:
        p += 1
print(p)


### FIXED CODE ###

a,b,c = map(int,input().split())
count = 0
for i in range(a,b+1):
    if c%i == 0:
        count += 1


print(count)
s = input()
t = input()

ans = len(t)
long = ans

for i in range(len(t)):
    tc = t[i]
    for j in range(0+i,len(s)):
        if tc == s[j]:
            count = 1
            for k in range(1,len(t)-i):
                if t[i+k] == s[j+k]:
                    count += 1
                else:
                    if ans > long - count:
                        ans = long - count
                    break

print(ans)

### FIXED CODE ###

s = input()
t = input()

ans = len(t)
long = ans

for i in range(len(s)+1-long):
    count = 0
    for j in range(long):
        if s[i+j] != t[j]:
            count += 1
    if count < ans:
        ans = count

print(ans)
print('YES' if (input().split().count('5')==2 and input().split().count('7')==1) else 'NO')

### FIXED CODE ###

s = input().split()
print('YES' if s.count('5')==2 and s.count('7')==1 else 'NO')
n , m = map(int , input().split())
edge = [[] for _ in range(m) ]
#print(edge)
for _ in range(m):
    a , b = map(int , input().split())
    a -= 1 ; b -= 1
    edge[a].append(b)
    edge[b].append(a)
print(edge)

def DFS(s):
    global visited
    #ret=1 if all(visited) else 0
    if all(visited):
        ret = 1
    else:
        ret = 0
    for e in edge[s]:
        print("e",e)
        if visited[e] == True:
            continue
        visited[e] = True
        ret += DFS(e)
        visited[e] = False
    return ret

visited = [False] * n
visited[0] = True
print(DFS[0])

### FIXED CODE ###

n , m = map(int , input().split())
edge = [[] for _ in range(n) ]
#print(edge)
for _ in range(m):
    a , b = map(int , input().split())
    a -= 1 ; b -= 1
    edge[a].append(b)
    edge[b].append(a)
#print(edge)

def DFS(s):
    global visited
    #ret=1 if all(visited) else 0
    if all(visited):
        ret = 1
    else:
        ret = 0
    for e in edge[s]:
        #print("e",e)
        if visited[e] == True:
            continue
        visited[e] = True
        ret += DFS(e)
        visited[e] = False
    return ret

ans = 0
visited = [False] * n
visited[0] = True
ans += DFS(0)
print(ans)
from collections import deque

def bfs(g_list, visited):
    q = deque([1])
    visited[1] = 0
    while q:
        curr_room = q.popleft()
        for next_room in g_list[curr_room]:
            if visited[next_room] >= 0:
                continue
            visited[next_room] = curr_room
            q.append(next_room)


def main():
    n, m = map(int, input().split()) 
    g_list = [ [] for _ in range(m+1)]
    visited = [-1] * (n+1)
    visited[0] = 0
    for i in range(m):
        a, b = map(int, input().split()) 
        g_list[a].append(b)
        g_list[b].append(a)
    bfs(g_list,visited)
    # print(visited)
    ans = visited[2:]
    if -1 in ans:
        print('No')
    else:
        print('Yes')
        for a in ans:
            print(a)

if __name__ == "__main__":
    main()

### FIXED CODE ###

from collections import deque

def bfs(g_list, visited):
    q = deque([1])
    visited[1] = 0
    while q:
        curr_room = q.popleft()
        for next_room in g_list[curr_room]:
            if visited[next_room] >= 0:
                continue
            visited[next_room] = curr_room
            q.append(next_room)


def main():
    n, m = map(int, input().split()) 
    g_list = [ [] for _ in range(n+1)]
    visited = [-1] * (n+1)
    visited[0] = 0
    # print(g_list)
    for i in range(m):
        a, b = map(int, input().split()) 
        g_list[a].append(b)
        g_list[b].append(a)
    bfs(g_list,visited)
    # print(visited)
    ans = visited[2:]
    if -1 in ans:
        print('No')
    else:
        print('Yes')
        for a in ans:
            print(a)

if __name__ == "__main__":
    main()
H, W = input().split(' ')
H = int(H)
W = int(W)
for i in range(W):
  a = input()
  print(a)
  print(a)

### FIXED CODE ###

H, W = input().split(' ')
H = int(H)
W = int(W)
for i in range(H):
  a = input()
  print(a)
  print(a)
x = int(input())

root = int(x**(0.2))

flag = 0
for i in range(root - 100, root + 100):
    for j in range(-40, root):
        if i!=j:
            if x%(i-j) == 0:
                if i**5-j**5 == x:
                    print(i, j)
                    flag = 1
                    break
    if flag:
        break

### FIXED CODE ###

s = input()
if s =='ABC':
  print('ARC')
if s == 'ARC':
  print('ABC')
# -*- coding: utf-8 -*-

while True:
    try:
        n = int(raw_input())
        if n < 3:
            print(0)
            continue
        list1 = range(2, n)
        list2 = []
        while True:
            i = list1.pop(0)
            list2.append(i)
            for x in list1:
                if x % i == 0:
                    list1.remove(x)
            if i**2 > list1[::-1][0]:
                break
        print(len(list2 + list1))
    except EOFError:
        break

### FIXED CODE ###

# -*- coding: utf-8 -*-

list = [1]*1000000
list[0] = 0
list[1] = 0
for i in range(1, 1000000):
    if list[i] == 1:
        for j in range(i**2, 1000000, i):
            list[j] = 0

for i in range(2, 1000000):
    list[i] += list[i -1]
while True:
    try:
        n = int(raw_input())
        print(list[n])
    except EOFError:
        break
# メモ化再帰
import math
import numpy as np
import copy
from collections import defaultdict, Counter
from itertools import product
from bisect import bisect_left, bisect_right

def s_inpl(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))

N = int(input())
h = inpl()

# 最小化問題なのでINFに初期化
INF = float("inf")
dp = [ INF ] * N

def solve(i):
    # DPの値が更新されていたらそのまま
    if dp[i] < INF:
        return dp[i]

    # 足場0のコストは0
    if i == 0:
        return 0

    # dp[i]の計算
    res = INF
    ## 足場i-1から来た場合
    res = min(res, solve(i-1) + abs(h[i] - h[i-1]))
    ## 足場i-2から来た場合
    if i > 1:
        res = min(res, solve(i-2) + abs(h[i] - h[i-2]))

    # メモ
    dp[i] = res

    return res


print(solve(N-1))

### FIXED CODE ###

import math
import numpy as np
import copy
from collections import defaultdict, Counter
from itertools import product
from bisect import bisect_left, bisect_right

def s_inpl(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))

N = int(input())
h = inpl()

INF = 10e11

# 最小化問題なのでINFに初期化
dp = [ INF for _ in range(100010) ]

# 初期状態
dp[0] = 0

# ループ
for i in range(1, N):
    dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]))
    if i > 1:
        dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]))

print(dp[N-1])
a,b=map(int,input().split());
c=a*b;
if(c%2==0)print(Even);
else print(Odd);

### FIXED CODE ###

a,b=map(int, input().split())
c=a*b%2
if c==0:
  print("Even")

else :
  print("Odd")
# -*- coding: utf-8 -*-
import sys,fraction
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    def dfs(res, flag, depth):
        if depth == N:
            return res
        if flag:
            return dfs(fraction.gcd(res, A[depth]), True, depth + 1)
        else:
            return max( dfs(res, True, depth + 1), dfs(fraction.gcd(res, A[depth]), False, depth + 1))

    N = int(lines.pop(0))
    A = list(map(int, lines.pop(0).split(' ')))
    print(dfs(0, False, 0) )
lines = [x.strip() for x in sys.stdin.readlines()]
solve(lines)

### FIXED CODE ###

# -*- coding: utf-8 -*-
import sys,fractions
from functools import reduce
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    N = int(lines.pop(0))
    A = list(map(int, lines.pop(0).split(' ')))

    _l = 0
    L = []
    for i in range(N-1):
        _l = fractions.gcd(_l, A[i])
        L.append(_l)
    L.insert(0,0)

    _r = 0
    R = []
    for i in range(N-1):
        _r = fractions.gcd(_r, A[N-i-1])
        R.append(_r)
    R.reverse()
    R.append(0)

    print(max([fractions.gcd(l,r) for l, r in zip(L,R)]))



lines = [x.strip() for x in sys.stdin.readlines()]

#
# solve !!
#
solve(lines)
X = int(input())
C= [i**5 for i in range(119)]

a = 0
b = 0

for a in range(len(C)):
    for b in range(len(C)):
        if C[a] + C[b] == X:
            print(a, -b)
            exit(0)
        elif C[a] - C[b] == X:
            print(a, b)
            exit(0)


### FIXED CODE ###

import sys
input = sys.stdin.readline

def main():
    s = input().rstrip()

    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')


if __name__ == '__main__':
    main()
i = 1
while True:
x = int(input())
if x == 0:
   break
else:
   print("Case %d: %d".format(i,x))
   i += 1



### FIXED CODE ###

i = 1
while True:
   x = int(input())
   if x == 0:
      break
   else:
      print("Case {}: {}".format(i,x))
      i += 1
import sys

N = int(input())
XY = [[int(_) for _ in input().split()] for i in range(N)]

mc = [0, 0]
maxl = 0

for x, y in XY:
    l = abs(x) + abs(y)
    maxl = max(maxl, l)
    mc[l % 2] += 1

if mc[0] > 0 and mc[1] > 0:
    print(-1)
    sys.exit()

if maxl > 20:
    raise

def calc(sx, sy, dx, dy, d):
    #print("#", sx, sy, dx, dy)
    x = dx - sx
    y = dy - sy
    tx = x + 3 * d - y
    ty = x + 3 * d + y
    dirs = ("RR", "RD", "DD"), ("RU", "RL", "LD"), ("UU", "LU", "LL")
    ds = {"R": (-d, 0), "L": (d, 0), "U": (0, d), "D": (0, -d)}
    dir = dirs[ty // (2 * d)][tx // (2 * d)]
    ex, ey = sx, sy
    for d in dir:
        ex += ds[d][0]
        ey += ds[d][1]
    #print("*", dir, ex, ey)
    return dir, ex, ey


ds = [9, 3, 1]
ds0 = ds

w0 = ""
x0, y0 = 0, 0

if mc[1] > 0:
    ds0 = [1] + ds0
    w0 += "L"
    x0 += 1

print(len(ds0))
print(*ds0)

for i in range(N):
    w = w0
    x, y = x0, y0
    for j, d in enumerate(ds):
        wc, x, y = calc(x, y, XY[i][0], XY[i][1], d)
        w += wc
    print(w)





### FIXED CODE ###

import sys

N = int(input())
XY = [[int(_) for _ in input().split()] for i in range(N)]

mc = [0, 0]
maxl = 0

for x, y in XY:
    l = abs(x) + abs(y)
    maxl = max(maxl, l)
    mc[l % 2] += 1

if mc[0] > 0 and mc[1] > 0:
    print(-1)
    sys.exit()

#print(maxl)

def calc(sx, sy, ex, ey, d):
    dx, dy = ex - sx, ey - sy
    rx, ry = dx - dy, dx + dy
    if rx > 0:
        if ry > 0:
            d, x, y = "R", sx + d, sy
        else:
            d, x, y = "D", sx, sy - d
    else:
        if ry > 0:
            d, x, y = "U", sx, sy + d
        else:
            d, x, y = "L", sx - d, sy
    return d, x, y

import math

l = math.ceil(math.log(maxl + 1, 2))

ms = [2 ** (l - i - 1) for i in range(l)]

rms = ms

if mc[0] > 0:
    rms = [1] + ms

print(len(rms))
print(*rms)

for ex, ey in XY:
    x, y = 0, 0
    w = ""
    if mc[0] > 0:
        w = "R"
        x += 1
    for m in ms:
        d, x, y = calc(x, y, ex, ey, m)
        w += d
    print(w)
a=int(input())
b=int(input())
if a%500<b:
  print('Yes')
else('No')

### FIXED CODE ###

a=int(input())
b=int(input())
if a%500 <= b:
  print('Yes')
else: print('No')
nums = input()
set_nums = list(set(nums))
other = sum(nums) - sum(set_nums)
del set_nums[other]
print(set_nums[0])

### FIXED CODE ###

nums = map(int, input().split())
d = {}
for n in nums:
  d.setdefault(n, 0)
  d[n] += 1
print(list(d.keys())[list(d.values()).index(1)])
n = int(input(), 10)
a = list(map(int, input().split()))
greatCDlist = []

for i in range(n):
  pop = a.pop(i)
  greatCD = 1
  for j in range(n):
    if j == 0:
      greatCD = gcd(a[0], a[1])
    else:
      greatCD = gcd(greatCD, a[j])
  a.insert(i, pop)
  greatCDlist.append(greatCD)

maxg = 1
for i in range(n):
  if maxg > greatCDlist[i]:
    maxg = greatCDlist[i]

print(maxg)


def gcd(m, n):
  if m < n:
    m ^= n
    n ^= m
    m ^= n
  if n == 0:
    return m
  else:
    return gcd(n, n % m)

### FIXED CODE ###

n = int(input(), 10)
a = list(map(int, input().split()))
greatCDlist = []


def gcd(m, n):
    if m < n:
        m ^= n
        n ^= m
        m ^= n
    if n == 0:
        return m
    else:
        return gcd(n, m % n)


left = [0 for i in range(n+1)]
right = [0 for i in range(n+1)]

for i in range(n):
    left[i+1] = gcd(left[i], a[i])


for i in range(n-1, -1, -1):
    right[i] = gcd(right[i+1], a[i])


result = 0
for i in range(n):
    l = left[i]
    r = right[i+1]
    result = max(result, gcd(l, r))

print(result)
N = int(input())
S, T  = input().split()

for i in range(N):
    r += S[i] + T[i]
    
print(r)


### FIXED CODE ###

N = int(input())
S, T  = input().split()
r = ''

for i in range(N):
    r += S[i] + T[i]

print(r)
n=int(input())
dp=list(map(int,input().split()))
m=int(input())
tp=list(map(int,input().split()))
d=dict()

ans="YES"

for di in dp:
    if di in d:
        d[di]+=1
    else:
        d[di]=1

for ti in tp:
    if d[ti]==0:
        ans="No"
        break
    else:
        d[ti]-=1
print(ans)

### FIXED CODE ###

import collections
n=int(input())
dp=collections.Counter(int(x) for x in input().split())
m=int(input())
tp=collections.Counter(int(x) for x in input().split())
ans="YES"
for k,v in tp.items():
    if dp[k]<v:
        ans="NO"
        break
print(ans)
# ABC089-D
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(input())
def S(): return list(input())
h,w,d=IL()
A=[IL() for i in range(h)]
Al=[0]*(h*w+1)
for i in range(h):
    for j in range(w):
        Al[A[i][j]]=[i,j]

rui={}
for i in range(d):
    T=[0]
    for j in range(1,h*w+1-i-d,d):
        T.append(abs(Al[j+i][0]-Al[j+d+i][0])+abs(Al[j+i][1]-Al[j+d+i][1]))
    for j in range(len(T)-1):
        T[j+1]+=T[j]
    rui[(i+1)%d]=T
q=I()
for w in range(q):
    l,r=IL()
    idx=l%d
    li=l//d
    ri=r//d
    print(rui[idx][ri]-rui[idx][li])

### FIXED CODE ###

# ABC089-D
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(input())
def S(): return list(input())
h,w,d=IL()
A=[IL() for i in range(h)]
Al=[0]*(h*w+1)
for i in range(h):
    for j in range(w):
        Al[A[i][j]]=[i,j]

rui={}
for i in range(d):
    T=[0]
    for j in range(1,h*w+1-i-d,d):
        T.append(abs(Al[j+i][0]-Al[j+d+i][0])+abs(Al[j+i][1]-Al[j+d+i][1]))
    for j in range(len(T)-1):
        T[j+1]+=T[j]
    rui[(i+1)%d]=T
q=I()
for w in range(q):
    l,r=IL()
    idx=l%d
    if idx==0:
        li=l//d-1
        ri=r//d-1
    else:
        li=l//d
        ri=r//d
    print(rui[idx][ri]-rui[idx][li])
N,Q = map(int, input().split())
S = input()
t = [0] * (N+1)

for i in range(N):
    t[i+1] = t[i] + (1 if S[i:i+2] == 'AC' else 0)

for i in range(Q):
    l,r = map(int, input().split())
    print(t[r-1] - t[l-1])


### FIXED CODE ###

basis = input()
if basis == 'A':
    print('T')
elif basis == 'T':
    print('A')
elif basis == 'C':
    print('G')
elif basis == 'G':
    print('C')
S = input()
if S == 'ABC' :
    Next = 'ARC'
else :
    Next = 'ABC'
print Next

### FIXED CODE ###

S = input()
if S == 'ABC' :
    Next = 'ARC'
else :
    Next = 'ABC'
print (Next)
s = input()[:-1]

length = len(s)

for a in range(length, 1, -1):
  temp = s[:a]
  if len(temp) %2 == 0:
    half = len(temp)//2
    if temp[:half] == temp[half:]:
      ans = len(temp)
    break #ここでbreakするために，forを"大きいところ"から回してる
    
print(ans)

### FIXED CODE ###

s = input()[:-1]

length = len(s)

for a in range(length, 1, -1):
  temp = s[:a]
  if len(temp) %2 == 0:
    half = len(temp)//2
    if temp[:half] == temp[half:]:
      ans = len(temp)
      break #ここでbreakするために，forを大きいところから回してる
    
print(ans)
a, b, c, d = map(int, input().split())
if a+b+c+d==7:
    print(str(a)+'+'+str(b)+'+'+str(c)+'+'+str(d)+'=7')
elif a+b+c-d==7:
    print(str(a)+'+'+str(b)+'+'+str(c)+'-'+str(d)+'=7')
elif a+b-c+d==7:
    print(str(a)+'+'+str(b)+'-'+str(c)+'+'+str(d)+'=7')
elif a+b-c-d==7:
    print(str(a)+'+'+str(b)+'-'+str(c)+'-'+str(d)+'=7')
elif a-b+c+d==7:
    print(str(a)+'-'+str(b)+'+'+str(c)+'+'+str(d)+'=7')
elif a-b+c-d==7:
    print(str(a)+'-'+str(b)+'+'+str(c)+'-'+str(d)+'=7')
elif a-b-c+d==7:
    print(str(a)+'-'+str(b)+'-'+str(c)+'+'+str(d)+'=7')
elif a-b-c-d==7:
    print(str(a)+'-'+str(b)+'-'+str(c)+'-'+str(d)+'=7')
    

### FIXED CODE ###

a, b, c, d = map(int, list(input()))
if a+b+c+d==7:
    print(str(a)+'+'+str(b)+'+'+str(c)+'+'+str(d)+'=7')
elif a+b+c-d==7:
    print(str(a)+'+'+str(b)+'+'+str(c)+'-'+str(d)+'=7')
elif a+b-c+d==7:
    print(str(a)+'+'+str(b)+'-'+str(c)+'+'+str(d)+'=7')
elif a+b-c-d==7:
    print(str(a)+'+'+str(b)+'-'+str(c)+'-'+str(d)+'=7')
elif a-b+c+d==7:
    print(str(a)+'-'+str(b)+'+'+str(c)+'+'+str(d)+'=7')
elif a-b+c-d==7:
    print(str(a)+'-'+str(b)+'+'+str(c)+'-'+str(d)+'=7')
elif a-b-c+d==7:
    print(str(a)+'-'+str(b)+'-'+str(c)+'+'+str(d)+'=7')
elif a-b-c-d==7:
    print(str(a)+'-'+str(b)+'-'+str(c)+'-'+str(d)+'=7')
S = list(input()) 
if S[0] != "A":
    S.insert(0,"A")
if S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] !="A":
    S.insert(4,"A")
if S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B" and S[6] !="A":
    S.insert(6,"A")
if S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B" and S[6] == "A" and S[7] == "R" and S[8] !="A":
    S.insert(8,"A")
if   S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B" and S[6] == "A" and S[7] == "R" and S[8] == "A" and len(S) ==9:
    print("YES")
else:
    print("NO")

### FIXED CODE ###

import sys
S = list(input()) 
#judge =1
if S[0] != "A":
    S.insert(0,"A")
#if S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] !="A":
if len(S) < 4:
    print("NO")
    sys.exit()
elif S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H":
    if len (S) == 4:
        S.insert(4,"A")
    elif S[4] != "A":
        S.insert(4,"A")    
else:
    print("NO")
    sys.exit()
if len(S) <6:
    print("NO")
    sys.exit()
elif S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B":
    if len (S) == 6:
        S.insert(6,"A")
    elif S[6] != "A":
        S.insert(6,"A")
else:
    print("NO")
    sys.exit()
if len(S) < 8:
    print("NO")
    sys.exit()
elif S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B" and S[6] == "A" and S[7] == "R":
    if len (S) == 8:
        S.insert(8,"A")
    elif S[8] != "A":
        S.insert(8,"A")
else:
    print("NO")
    sys.exit()
if   S[0] =="A" and S[1] == "K" and S[2] == "I" and S[3] == "H" and S[4] =="A" and S[5] =="B" and S[6] == "A" and S[7] == "R" and S[8] == "A" and len(S) ==9:
    print("YES")
else:
    print("NO")
import sys
x = sys.argv[0]
t = sys.argv[1]
print X - t


### FIXED CODE ###

l = raw_input().split()
x = l[0]
t = l[1]
if int(x) - int(t) > 0:
    print int(x) - int(t)
else:
    print 0