Harryxun/stf_run huggingface dataset:
import numpy as np
h, w = map(int, input().split())
colors = np.zeros((h,w))
for i in range(h):
    s = input()
    for j,c in enumerate(s):
        if c=='#':
            colors[i,j] = 1

def tonari(pos):
    i,j = pos
    ans = []
    if i==0:
        ans.append((i+1,j))
    elif i==h-1:
        ans.append((i-1,j))
    else:
        ans.append((i-1,j))
        ans.append((i+1,j))
    if j==0:
        ans.append((i,j+1))
    elif j==w-1:
        ans.append((i,j-1))
    else:
        ans.append((i,j-1))
        ans.append((i,j+1))
    
    return ans

# 深さ優先探索をする
# マス(0,0)からスタート
# 次の仕切り直しで使うスタート位置のリストnext_start
# すでに訪ねたかどうかを表すh*wの表 visited=1 
# current_positionの前後左右を見てもしcurrent_colorと異なればそっちに動く

current_position = (0,0)
current_color = colors[current_position]
current_group = 0
groups = {0:[1-current_color, current_color]} # {group_num:(white_num,black_num)}
next_visit = []
other_group = []

unvisited = [(i,j) for i in range(h) for j in range(w)]
unvisited.remove((0,0))

while True:
    # current_positionの前後左右を見る
    #print(current_position, groups)
    neighbors = tonari(current_position)
    for ngb in neighbors:
        if colors[ngb] != current_color and ngb in unvisited and ngb not in next_visit:
            next_visit.append(ngb)
        # もしnon_visitedかつcurrent_colorと異なればnext_visitに追加
        # それ以外は何もしない
    
    #print(next_visit)

    # next_visitが空でないとき
    if len(next_visit) > 0:
        current_position = next_visit.pop()
        current_color = colors[current_position]
        groups[current_group][int(current_color)] += 1
        unvisited.remove(current_position)
        # next_visitの中から次の移動先を取り出して
        # colorをみてgroupに追加
        # current_positionとcurrent_colorを更新

    elif len(next_visit) == 0:
        # next_visitが空のとき
        if len(unvisited) == 0:
            break
        else:
            current_position = unvisited.pop()
            current_color = colors[current_position]
            current_group += 1
            groups[current_group] = [1-current_color, current_color]
            # unvisitedの中から一つ選んで
            # current_position, color更新
            # current_group更新

#print(groups)
ans = 0
for g in groups:
    black, white = groups[g]
    ans += black*white
print(int(ans))



### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)

h,w=map(int,input().split())
s=[input() for _ in range(h)]
t=[[None]*w for _ in range(h)]

def dfs(i,j,color):

  if not (0<=i<h and 0<=j<w):return 0,0
  if s[i][j]==color: return 0,0
  if t[i][j]:return 0,0

  t[i][j]=True
  wh,bl=0,0
  if s[i][j]=="#":
    bl+=1
  else:
    wh+=1

  tmp1,tmp2=dfs(i+1,j,s[i][j])
  wh,bl=wh+tmp1,bl+tmp2

  tmp1,tmp2=dfs(i-1,j,s[i][j])
  wh,bl=wh+tmp1,bl+tmp2
        
  tmp1,tmp2=dfs(i,j-1,s[i][j])
  wh,bl=wh+tmp1,bl+tmp2

  tmp1,tmp2=dfs(i,j+1,s[i][j])
  wh,bl=wh+tmp1,bl+tmp2

  return wh,bl

ans=0
for i in range(h):
  for j in range(w):
    a,b=dfs(i,j,"!")
    ans+=a*b

print(ans)
n = int(input())
A = list(map(int, input().split()))
q = int(input())
mi = map(int, input().split())
tmp = {}

def solve(i, m):
    if (m == 0):
        return True
    if (i >= n):
        return False
    if (i,m) in tmp:
        return tmp[(i,m)]
    res = solve(i + 1, m) or solve(i + 1, m - A[i])
    tmp[(i,m)] = res
    return res

for j in range(q):
    if solve(0, mi):
        print("yes")
    else:
        print("no")

### FIXED CODE ###

n = int(input())
A = list(map(int, input().split()))
q = int(input())
mi = map(int, input().split())
t = {}

def solve(i, m):
    if (m == 0):
        return True
    if (i >= n):
        return False
    if (i,m) in t:
        return t[(i,m)]
    res = solve(i + 1, m) or solve(i + 1, m - A[i])
    t[(i,m)] = res
    return res

for m in mi:
    if solve(0, m):
        print("yes")
    else:
        print("no")
s = input()
txt = []

for c in s:
  if c == 'B' && len(txt) > 0:
    txt.pop()
  else:
    txt.append(c)
    
print(''.join(txt))


### FIXED CODE ###

s = input()
txt = []

for c in s:
    if c == 'B':
        if len(txt):
            txt.pop()
    else:
        txt.append(c)

print(''.join(txt))
#include <iostream>
#include <string>
using namespace std;

int main(){
    string input_str;

    cin >> input_str;

    input_str[5] = ' ', input_str[13] = '';

    cout << input_str << endl;

    return 0;
}


### FIXED CODE ###

def main():
    s = input()
    print(s.replace(",", " "))

if __name__ == "__main__":
    main()
a,b,c,d=map(int,input().split())
a=a-d
c=c-b
if c>=a:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

s,w=map(int,input().split())
if w >= s:
    print("unsafe")
else:
    print("safe")
s,t=map(input().split())
print(s+t)

### FIXED CODE ###

s,t=input().split()
print(t+s)
C = [input() for _ in range(3)]
ans = C[0][0] + C[1][1] + C[2][2]
print(ans)

### FIXED CODE ###

N = int(input())
ans = N // 3
print(ans)
result = dict()
AC, WA = 0, 0
for p,s in PS:
    p = int(p)
    if not (p in result):
        result [p] = s
        if s == "WA":
            WA += 1
        elif s == "AC":
            AC += 1
    elif result[p] == "AC":
        continue
    else:
        result[p] = s
        if s == "WA":
            WA += 1
        elif s == "AC":
            AC += 1
print(AC, WA)

### FIXED CODE ###

_, M = map(int, input().split())
PS = [tuple(input().split()) for _ in range(M)]
result = dict()
AC, WA = 0, 0
for p,s in PS:
    i = int(p)
    if not (i in result):
        if s == "WA":
            result[i] = 1
        elif s == "AC":
            AC += 1
            result [i] = "AC"
    else:
        if result[i] != "AC":
            if s == "WA":
                result[i] += 1
            if s == "AC":
                AC += 1
                WA += result[i]
                result[i] = s
print(AC, WA)
import numpy as np
from collections import defaultdict
import bisect

M = 1000000007
N = int(input())
left = list(map(int, input().split()))

indices = defaultdict(list)
for i, x in enumerate(left):
    indices[x].append(i)


def dp(t, n1, n2, n3):
    remaining = n1 + n2 + n3
    if remaining < 0:
        return 0
    cached = t[n1][n2][n3]
    if cached is not None:
        return cached
    last_cnt = left[remaining - 1] + 1
    res = 0
    if last_cnt == n1:
        res += dp(t, n1 - 1, n2, n3)
        res %= M
    if last_cnt == n2:
        res += dp(t, n1, n2 - 1, n3)
        res %= M
    if last_cnt == n3:
        res += dp(t, n1, n2, n3 - 1)
        res %= M
    # print(f"{remaining}: ({n1},{n2},{n3}) => {res}")
    t[n1][n2][n3] = res
    return res


def solve():
    heads = [0, 0, 0]
    for i in range(N):
        k = len(indices[i])
        if k == 3:
            heads[0] = heads[1] = heads[2] = i + 1
        elif k == 2:
            heads[0] = heads[1] = i + 1
        elif k == 1:
            heads[0] = i + 1
        else:
            break
    t = [
        [[None] * (heads[2] + 1) for _ in range(heads[1] + 1)]
        for _ in range(heads[0] + 1)
    ]
    t[0][0][0] = 1
    num_colors = len(indices[0])
    base = dp(t, heads[0], heads[1], heads[2])
    if len(indices[0]) < 3:
        return 3 * base
    else:
        return base


print(solve())


### FIXED CODE ###

import itertools
import sys
from collections import Counter

sys.setrecursionlimit(10 ** 9)
M = 1000000007
N = int(sys.stdin.readline())
left = list(map(int, sys.stdin.read().split()))
counter = Counter(left)


def dp(t, ns):
    cached = t.get(ns)
    if cached is not None:
        return cached
    remaining = sum(ns)
    assert remaining > 0
    last_cnt = left[remaining - 1] + 1
    n1, n2, n3 = ns
    res = 0
    if last_cnt == n1:
        res += dp(t, tuple(sorted([n1 - 1, n2, n3])))
        res %= M
    if last_cnt == n2:
        res += dp(t, tuple(sorted([n1, n2 - 1, n3])))
        res %= M
    if last_cnt == n3:
        res += dp(t, tuple(sorted([n1, n2, n3 - 1])))
        res %= M
    # print(f"{remaining}: ({n1},{n2},{n3}) => {res}")
    t[ns] = res
    return res


def solve():
    h = [0, 0, 0]
    for i in range(N):
        k = counter[i]
        if k == 3:
            h[0] = h[1] = h[2] = i + 1
        elif k == 2:
            h[0] = h[1] = i + 1
        elif k == 1:
            h[0] = i + 1
        else:
            break
    if sum(h) != N:
        return 0
    t = dict()
    t[0, 0, 0] = 1
    res = dp(t, tuple(sorted(h)))
    return (res * len(set(itertools.permutations(h)))) % M


print(solve())
n=int(input())
h=list(map(int,input().split()))
i=0
cnt=0
for j in h:
  if i<=j:
    cnt+=1
    i=j
print(cnt)

### FIXED CODE ###

a,b=map(int,input().split())
if a==b:
  print(a+b)
elif a<b:
  print(b+b-1)
else:
  print(a+a-1)
import sys  
import numpy as np

input = sys.stdin.readline

S_ = input()
T = input()

S_ = list(S_)[:-1]
T = list(T)[:-1]

for i in range(len(S_)-len(T)+1):
    part = S_[-len(T)-i:-i]
    j = False
    for k in range(len(part)-1,-1,-1):
        if part[k] == "?":
            if k==0:
                j = True
        elif part[k] == T[k]:
            if k==0:
                j = True

        else:

            break
    if j:
        break


if j:
    for p in range(len(T)):
        S_[len(S_)-len(T)-i+p] = T[p]
    # print("*",S_)
    for k in range(len(S_)):
        if S_[k] == "?":
            S_[k] = "a"

    print("".join(S_))
else:
    print("UNRESTORABLE")

### FIXED CODE ###


import sys  
import numpy as np

input = sys.stdin.readline

S_ = input()
T = input()

S_ = list(S_)[:-1]
T = list(T)[:-1]

j = False
for i in range(len(S_)-len(T)+1):
    if i==0:
        part = S_[-len(T):]
    else :
        part = S_[-len(T)-i:-i]
    j = False
    for k in range(len(part)-1,-1,-1):
        if part[k] == "?":
            if k==0:
                j = True
            continue
        elif part[k] == T[k]:
            if k==0:
                j = True
        else:
            break
    if j:
        break


if j:
    for p in range(len(T)):
        S_[len(S_)-len(T)-i+p] = T[p]
    # print("*",S_)
    for k in range(len(S_)):
        if S_[k] == "?":
            S_[k] = "a"

    print("".join(S_))
else:
    print("UNRESTORABLE")
while True:
    n = int(input())
    if n == 0:
        break
    dp = [0]
    for i in range(n):
        a = int(input()))
        dp[i] = (max(dp[i] + a, a))
    print(max(dp))

### FIXED CODE ###

while True:
    n = int(input())
    if n == 0:
        break
    dp = [-1e6]
    for i in range(n):
        a = int(input())
        dp.append(max(dp[i] + a, a))
    print(max(dp))
import string,sys
def I(): return int(sys.stdin.readline().rstrip())
N = I()
abc = string.ascii_lowercase
def main(N):
    if N<=26:
        return abc[N-1]
    if N%26==0:
        return abc[N//26-2]+'z'
    return main(N//26)+abc[N%26-1]
print(main(N))


### FIXED CODE ###

import string,sys
def I(): return int(sys.stdin.readline().rstrip())
N = I()
abc = string.ascii_lowercase
def main(N):
    if N<=26:
        return abc[N-1]
    if N%26==0:
        return main(N//26-1)+abc[-1]
    return main(N//26)+abc[N%26-1]
print(main(N))
n=int(raw_input())
s=raw_input()
ans=0
for i in xrange(n):
    if s[i]=="I":
        cnt+=1
        ans=max(ans,cnt)
    elif s[i]=="D":
        cnt-=1
        ans=max(ans,cnt)
print(ans)


### FIXED CODE ###

n=int(raw_input())
s=raw_input()
ans=0;cnt=0
for i in xrange(n):
    if s[i]=="I":
        cnt+=1
        ans=max(ans,cnt)
    elif s[i]=="D":
        cnt-=1
        ans=max(ans,cnt)
print(ans)
A = input()
_ = input()
_ = input()
_ = input()
E = input()
k = input()

if (E-A) > k:
  print(":(")
else:
  print("Yay!")

### FIXED CODE ###

A = int(input())
_ = input()
_ = input()
_ = input()
E = int(input())
k = int(input())

if (E-A) > k:
    print(":(")
else:
    print("Yay!")
while 1:
    e = int(input().strip())
    if e ==0:break
    m=e
    z =0
    while z**3 <= e:
        y=0
        while y **2 <= e - z**3:
            x = e - y**2 - z**3 
            if m > x+y+z: m = x+y+z 
            y+=1
        z+=1
    print(m)


### FIXED CODE ###

import math
while 1:
    e = int(input().strip())
    if e ==0:break
    m=e
    z =0
    while z**3 <= e:
        y = int(math.sqrt(e-z**3))
        x = e - y**2- z**3 
        if x < 0:break
        if m > x+y+z: m = x+y+z    
        z+=1
    print(m)
s = list(set(l))
num = range(len(s))
if len(s) <= K: print 0
else:
    for i in range(len(s)):
        num[i] = len([j for j in l if j == s[i]])
    sousa = len(s)-K
    num.sort()
    print sum(num[:sousa])


### FIXED CODE ###

#!/usr/bin/python
#coding: utf-8

from collections import Counter

N, K = map(int, raw_input().split())
l = map(int, raw_input().split())

s = list(set(l))
num = range(len(s))
if len(s) <= K: print 0
else:
    counter = Counter(l)
    nums = counter.values()
    sousa = len(s)-K
    nums.sort()
    print sum(nums[:sousa])
S = input()
T = input()
if (S == D[:len(S)]) and (len(S)+1==len(D)):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

S = input()
T = input()
if (S == T[:len(S)]) and ((len(S)+1)==len(T)):
    print('Yes')
else:
    print('No')
n,a,b = map(int,input().split())
ans = n//(a+b)*a
rem = n%(a+b)
ans +=(rem,a)
print(ans)

### FIXED CODE ###

n,a,b = map(int,input().split())
ans = n // (a+b) * a
rem = n % (a+b)
ans += min(rem,a)
print(ans)
A = input()
a,b = int(A.split' ')
if 0 < a < 11:
   print('b')
else:
   print('b+1000-100a')

### FIXED CODE ###

A = input()
b,c = (A.split(' '))
d = int(b)
e = int(c)
f = e - d * 100 + 1000

if 0 < d < 11:
    print(f)
else:
    print(e)
n = input()
l = list(map(int,input().split(" ")))
 
count = 0
 
while True:
  for i in range(n):
    if l[i]%2 == 0:
      l[i] = l[i]//2
    else:
      print(count)
      exit()
  count += 1
 

### FIXED CODE ###

print(input().count("1"))
N = int(input())
A = list(map(int, input().split()))

A.sort()
i = 0
if N % 2 == 1:
  i = 1
  if A[0] == A[1]:
    print(0)
    exit(0)
  if A[0] == 1:
    print(0)
    exit(0)
else:
  i = 2
  if A[0] != A[1]:
    print(0)
    exit(0)
  if A[0] == 0:
    print(0)
    exit(0)
res = 1
while i < N - 1:
  print("a", i)
  if A[i] == A[i + 1]:
    if N % 2 == 0:
      if A[i] != 2 * (i / 2 + 1) - 1:
        res = 0
        break
    else:
      if A[i] != 2 * (i // 2 + 1):
        res = 0
        break
    res *= 2
    i += 2
  else:
    res = 0
    break
print(res)



### FIXED CODE ###

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

A.sort()
mod = 10 ** 9 + 7
i = 0
res = 0
if N == 1:
  if A[0] == 0:
    print(1)
  else:
    print(0)
  exit(0)
if N % 2 == 1:
  res = 1
  i = 1
  if A[0] == A[1]:
    print(0)
    exit(0)
  if A[0] == 1:
    print(0)
    exit(0)
else:
  res = 2
  i = 2
  if A[0] != A[1]:
    print(0)
    exit(0)
  if A[0] == 0:
    print(0)
    exit(0)
while i < N - 1:
  if A[i] == A[i + 1]:
    if N % 2 == 0:
      if A[i] != 2 * (i / 2 + 1) - 1:
        res = 0
        break
    else:
      if A[i] != 2 * (i // 2 + 1):
        res = 0
        break
    res *= 2
    i += 2
  else:
    res = 0
    break
print(res % mod)
X = input().split(" ")
A = int(X[0])
B = int(X[1])
C = A * B
D = fractions.gcd(A,B)
print(round(C / D))

### FIXED CODE ###

from fractions import gcd
X = input().split(" ")
A = int(X[0])
B = int(X[1])
C = A * B
D = gcd(A,B)
print(C // D)
import heapq
n = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
ans = 0
q = []
heapq.heappush(q, A[0]*-1)
for i in range(1, n):
    print(q)
    tmp = heapq.heappop(q)
    ans += tmp
    heapq.heappush(q, A[i] * -1)
    heapq.heappush(q, A[i] * -1)

print(ans*-1)

### FIXED CODE ###

import heapq
n = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
ans = 0
q = []
heapq.heappush(q, A[0]*-1)
for i in range(1, n):
    tmp = heapq.heappop(q)
    ans += tmp
    heapq.heappush(q, A[i] * -1)
    heapq.heappush(q, A[i] * -1)

print(ans*-1)
a=n/k
if a >1:
    b=n%k
    if b==0:
        print(0)
    else:
        print(abs(b-k))
else:
    print(n)
    exit()

### FIXED CODE ###

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

b = n % k
c = abs(b - k)
if b < c:
    print(b)
else:
    print(c)
a=input()
s=list(map(int,input().split()))
count=0
counter=0
for i in a:
    counter=0
    for j in range(0,i):
      if counrer==1:
        break
        if s[i]>s[j] :
            count+=1
            counter+=1
print(count) 

### FIXED CODE ###

a=int(input())
s=list(map(int,input().split()))
count=0
min=s[0]
for i in range(0,a):
    if min>=s[i]:
        count+=1
        min=s[i]
print(count)
a,b=map(int, input().split(" ")
area=a*b
perimeter=2*(a+b)
print(area, perimeter)

### FIXED CODE ###

a, b = map(int, input().split(" "))
area = a*b
perimeter = 2*(a+b)
print(area, perimeter)
N = int((input())

if N % 2 == 0:
  print(N / 2)
else:
  print((N / 2) + 1)

### FIXED CODE ###

UNKO = int(input())
print(UNKO // 2 + UNKO % 2)
def count_bomb(y,x,h,w):
    ans=0
    for i in range(y-1,y+2):
        for j in range(x-1,x+2):
            if i>=0 and i<h and j>=0 and j<w:
                if s[i][j]=="#":
                    ans+=1
    return ans

h,w=map(int,input().split())
s=[list(input()) for _ in range(h)]
for i in range(h):
    for j in range(w):
        if s[i][j]==".":
            s[i][j]=count_bomb(i,j,h,w)
for i in range(h):
    print(*s[i],sep="")



### FIXED CODE ###

N=int(input())
S=list(input())
cnt=0
maxcnt=0
for i in range(N):
    if i==0:
        if S[0] in S[1:N]:
            cnt+=1
        if maxcnt<cnt:
            maxcnt=cnt
    elif i == N-1:
        if S[N-1] in S[0:N]:
            cnt-=1
    else:
        if S[i] not in S[0:i] and S[i] in S[i+1:N]:
            cnt+=1
            if maxcnt<cnt:
                maxcnt=cnt
        elif S[i] in S[0:i] and S[i] not in S[i+1:N]:
            cnt-=1
        else:
            pass
print(maxcnt)
import math
from collections import defaultdict
from functools import reduce

mod = pow(10, 9) + 7

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

graph = defaultdict(list)

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

src = 1
E = []
vis_set = set()
depth = [0]*(n+1)
def dfs_eulerTour(src):
	global vis_set, depth
	vis_set.add(src)
	E.append(src)

	for neighbour in graph[src]:
		if not neighbour in vis_set:
			depth[neighbour] = depth[src] + 1
			dfs_eulerTour(neighbour)
			E.append(src)

dfs_eulerTour(src)
D = [depth[x] for x in E]
N = len(D)
def get_h():
	H = [-1]*(n+1)
	for i, ele in enumerate(E):
		if H[ele]==-1:
			vis_set.add(ele)
			H[ele] = i 
	return H
H = get_h()
M = [[0]*(int(math.log2(N))+1) for i in range(N+1)]

def preprocess(D, N, M):
	for i in range(N):
		M[i][0] = i

	for j in range(1, int(math.log2(N))+1):
		i = 0
		while i + (1 << j) - 1 < N:
			M[i][j] = M[i][j-1] if D[M[i][j-1]] <= D[M[i + (1 << (j-1))][j-1]] else M[i + (1 << (j-1))][j-1]
			i += 1
preprocess(D, N, M)

def get_dist(u, v):
	
	def RMQ(i, j):
		k = int(math.log2(j - i))
		return M[i][k] if D[M[i][k]] <= D[M[j - (1<<k)][k]] else M[j - (1<<k)][k]

	if H[u] == H[v]:
		return 0
	elif H[u]> H[v]:
		u, v = v, u
		q = RMQ(H[u], H[v])
		lca = E[q]
	else:
		q = RMQ(H[u], H[v])
		lca = E[q]
	return depth[u] + depth[v] - 2*depth[lca]

def free_verts(cur_vert, vis_set):
	count = sum(get_dist(cur_vert, other_vert)>2 for other_vert in vis_set)
	return count

def dfs(src):
	rem_color = k
	vis_set = {src,}
	stack = [src]
	color = [1]*(n+1)
	color[src] = k
	rem_color -= 1
	while stack:
		v = stack.pop()
		for neighbour in graph[v]:
			if not neighbour in vis_set:
				vis_set.add(neighbour)
				stack.append(neighbour)
				add = free_verts(neighbour, vis_set)
				# print(neighbour, vis_set, add)
				color[neighbour] = (max(rem_color, 0) + add)%mod
				rem_color -= 1
	return reduce(lambda x, y: (x*y)%mod, color)
ans = dfs(src)
print(ans)

### FIXED CODE ###

from collections import defaultdict

mod = pow(10, 9) + 7

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

graph = defaultdict(list)

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

def dfs(v):
	global graph, k
	ans = k	# k choices of color for root
	stack = [v]
	vis_set = {v, }

	while stack:
		v = stack.pop()
		if v==0: 
			avail_count = k-1
		else: 
			avail_count = k-2
		for nxt in graph[v]:
			if nxt not in vis_set:
				if avail_count <= 0:
					return 0
				ans = (ans*avail_count)%mod
				avail_count -= 1
				stack.append(nxt)
				vis_set.add(nxt)
	return ans

ans = dfs(0)
print(ans)
a,b = map(ont,input().split())
if a % b == 0:
  print(0)
else:
  print(1)

### FIXED CODE ###

a,b = map(int,input().split())
if a % b == 0:
  print(0)
else:
  print(1)
N = int(input())
s = [int(input()) for i in range(2)]
  
if N==1:
  print('Hello World')

elif N==2:
  print(s[0]+s[1])

### FIXED CODE ###

n = int(input())
 
if n == 1:
	print("Hello World")
else:
	a = int(input())
	b = int(input())
	print(a+b)
from scipy.special import comb

N, M = map(int,input().split(" "))

ans = comb(N,2) + comb(M,2)


print(int(ans))

### FIXED CODE ###

import math

def perm(n, r):
    return math.factorial(n)//math.factorial(n-r)

def comb(n, r):
    if n <= 1:
        return 0
    return perm(n, r)//math.factorial(r)

N, M = map(int,input().split(" "))

ans = comb(N,2) + comb(M,2)


print(int(ans))
n, a, b = map(int, input().split())
if a+b == 0:
  x = 0
else:
	s = n//(a+b)
	t = n%(a+b)
	if t <= a:
    	x = s*a+t
	else:
    	x = s*a+a
print(x)

### FIXED CODE ###

n, a, b = map(int, input().split())
if a+b == 0:
  x = 0
else:
	s = n//(a+b)
	t = n%(a+b)
	if t <= a:
		x = s*a+t
	else:
		x = s*a+a
print(x)
a,b = map(int,input().split())
if (a + b)%2 ==0:
    print(round((a + b) / 2))
else: 
    print(round((a + b + 1) / 2)


### FIXED CODE ###

a,b = map(int,input().split())
if (a + b)%2 ==0:
    print(round((a + b) / 2))
else:
    print(round((a + b + 1) / 2))
a=int(input())
list = []

for i in a:
  list.append(int(input()))

print(list(set(list)))

### FIXED CODE ###

a=int(input())
lis = []

for i in range(a):
  lis.append(int(input()))

new = list(set(lis))
print(len(new))
s=input()
s=sorted(s)

if s[0]==s[1] and s[2]==s[3] and a[0] != s[2]:
	print("Yes")
else:
	print("No")

### FIXED CODE ###

s=input()
s=sorted(s)

if s[0]==s[1] and s[2]==s[3] and s[0] != s[2]:
	print("Yes")
else:
	print("No")
s=list(str(input()))
s[5]=' '
s[13]=' '
print('',join(s))

### FIXED CODE ###

s=list(str(input()))
s[5]=' '
s[13]=' '
print(''.join(s))
N,A,B=map(int,input().split())
print(min(N*A,B)

### FIXED CODE ###

N,A,B=map(int,input().split())
print(min(N*A,B))
n = int(input())
a = list(map(int, input().split()))
for  i in range(1,n+1):
    v  = a[i]
    j = i-1
    while a[j]>v and j>=0:
        a[j+1] = a[j]
        j -=1
    a[j] = v
    print(*a)


### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
for  i in range(n):
    v  = a[i]
    j = i-1
    while a[j]>v and j>=0:
        a[j+1] = a[j]
        j -=1

    a[j+1] = v
    print(*a)
#B-Frog2
N,K=map(int,input().split())
h=list(map(int,input().split()))

dp=[0 for i in range(N)]
dp[1]=abs(h[1]-h[0])


for i in range(2,N):
    min_num=10000
    for j in range(max(0,i-K),i):
        if min_num>dp[j]+abs(h[i]-h[j]):
            min_num=dp[j]+abs(h[i]-h[j])
    dp[i]=min_num

print(dp)

### FIXED CODE ###

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

dp=[0 for i in range(N)]
dp[1]=abs(H[1]-H[0])

for i in range(2,N):
    dp[i]=min(dp[i-1]+abs(H[i]-H[i-1]),dp[i-2]+abs(H[i]-H[i-2]))
print(dp[N-1])
a,b,c=map(int,input().split())
for i in range(100):
  if int(i*1.08)==a and int(i*1.1)==b:
    print(i)
    exit(0)
print(-1)

### FIXED CODE ###

a,b=map(int,input().split())
for i in range(10010):
  if i*8//100==a and i//10==b:
    print(i)
    exit(0)
print(-1)
package main

import (
	"fmt"
)

func main(){
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	if a < b && b < c{
		fmt.Printf("Yes\n")
	}
	else{
		fmt.Printf("No\n")
	}
}


### FIXED CODE ###

(a, b, c) = [int(i) for i in input().split()]
if a < b:
    if b < c:
        print('Yes')
    else:
        print('No')
else:
    print('No')