Harryxun/stf_run huggingface dataset:
N = int(input())
H = list(map(int, input().split(" ")))
for i in range(N):
    if i==0:
        cnt+=1
    else:
        h=H[i]
        c=0
        for j in range(i):
            if H[j]>h:
                c=1
        if c==0:
            cnt+=1
print(cnt)


### FIXED CODE ###

N = int(input())
H = list(map(int, input().split(" ")))
cnt=0
for i in range(N):
    if i==0:
        cnt+=1
    else:
        h=H[i]
        c=0
        for j in range(i):
            if H[j]>h:
                c=1
        if c==0:
            cnt+=1
print(cnt)
S = input()
n = len(S)
#与えられた文字列をリスト化し分割
lst = list(n)

array = []
for i in range(n):
    array.append(lst[2*i])

new_lst = "".join(array)
print(new_lst)

### FIXED CODE ###

s = list(input())
array = []
for i in range(len(s)):
    if i % 2 == 0:
        array.append(s[i])
        #print(array)

print("".join(array),end="")
N = int(input())

for i in range(1, N):
    n = i*i
    if n > N:
        break
        
    res = n

print(res)

### FIXED CODE ###

N = int(input())

for i in range(N+1):
    n = i*i
    if n > N:
        break
        
    res = n

print(res)
import math
import sys
from functools import reduce
def f(n):
    res = 0
    while(n%2 == 0):
        res += 1
        n //= 2
    return res

def lcm(a, b):
    return a // math.gcd(a, b) * b

n, m = map(int, input().split())
A = list(map(lambda x: int(x) // 2, input().split()))

F = set()
for a in A:
    F.add(f(a))
if(len(F) != 1):
    print(0)
    sys.exit()

l = reduce(lcm, A)
ans = - (- (m // 2) // l)
print(ans)

### FIXED CODE ###

from functools import reduce
def f(n):
    res = 0
    while(n%2 == 0):
        res += 1
        n //= 2
    return res

def gcd(a, b):
    return a if b == 0 else gcd(b, a%b)

def lcm(a, b):
    return a // gcd(a, b) * b

n, m = map(int, input().split())
A = list(map(lambda x: int(x) // 2, input().split()))

l = reduce(lcm, A, 1)
for a in A:
    if((l // a) % 2 == 0):
        print(0)
        break

else:
    ans = (m // l +1) // 2
    print(ans)
n = int(input())
ab = []
for _ in range(n):
    a, b = map(int, input().split())
    ab.append((a, b))
di = {}
def gcd(a, b):
    while b!=0:
        a, b = b, a%b
    return abs(a)
for a, b in ab:
    g = gcd(a, b)
    a, b = a//g, b//g
    if a*b>0:
        ind = (abs(a), abs(b))
    elif a*b<0:
        ind = (abs(b), abs(a))
    else:
        ind = 0
    if ind in di:
        x, y = di[ind]
    else:
        x = y = 0
    if a*b==0:
        if b!=0:
            di[0] = (x+1, y)
        elif a!=0:
            di[0] = (x, y+1)
    else:
        if a*b>0:
            di[ind] = (x+1, y)
        else:
            di[ind] = (x, y+1)
mod = 10**9+7
ans = 1
for i, j in di.values():
    ans *= (pow(2, i, mod)+pow(2, j, mod)-1)
    ans %= mod
print(ans-1)

### FIXED CODE ###

n = int(input())
ab = []
for _ in range(n):
    a, b = map(int, input().split())
    ab.append((a, b))
di = {}
z = 0
def gcd(a, b):
    while b!=0:
        a, b = b, a%b
    return a
for a, b in ab:
    if a*b!=0:
        g = gcd(abs(a), abs(b))
        a, b = a//g, b//g
    if a*b>0:
        ind = (abs(a), abs(b))
    elif a*b<0:
        ind = (abs(b), abs(a))
    else:
        ind = 0
    if ind in di:
        x, y = di[ind]
    else:
        x = y = 0
    if a*b==0:
        if b!=0:
            di[ind] = (x+1, y)
        elif a!=0:
            di[ind] = (x, y+1)
        else:
            z += 1
    else:
        if a*b>0:
            di[ind] = (x+1, y)
        else:
            di[ind] = (x, y+1)
mod = 10**9+7
ans = 1
for i, j in di.values():
    ans *= (pow(2, i, mod)+pow(2, j, mod)-1)
    ans %= mod
print((ans+z-1)%mod)
n=input()
n=int(n)

if n=3 or 5 or 7:
  print('YES')
  
else:
  print('NO')

### FIXED CODE ###

n=input()
n=int(n)

if n==3 or n==5 or n==7:
  print('YES')
  
else:
  print('NO')
import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
A
H, W, K = LI()
c = SRL(H)

ans=0
 
for i in range(2**H):
    seen=[]
    for n in range(H):
        if ((i>>n) & 1):
            seen.append(c[n])
    for j in range(2**W):
        count=0
        for m in range(W):
            if ((j>>m) & 1):
                for l in range(len(seen)):
                    if seen[l][m]=="#":
                        count+=1

        if count==K:
            ans+=1
print(ans)

### FIXED CODE ###

import sys
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7

H, W, K = LI()
c = SRL(H)

ans=0
 
for i in range(2**H):
    seen=[]
    for n in range(H):
        if ((i>>n) & 1):
            seen.append(c[n])
    for j in range(2**W):
        count=0
        for m in range(W):
            if ((j>>m) & 1):
                for l in range(len(seen)):
                    if seen[l][m]=="#":
                        count+=1

        if count==K:
            ans+=1
print(ans)
a = input()
b = input()
c = input()
d = input()

print(max((a * b), (c * d)))

### FIXED CODE ###

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

a, b, c, d = map(int, input().strip().split())
print(max(a*b, c*d))
import math
r=int(input())
print("{} {}".format(r*r*math.pi,r*2*math.pi))

### FIXED CODE ###

import math
r=float(input())
print("{:0.6f} {:0.6f}".format(r**2*math.pi,r*2*math.pi))
#c dp version
n,m = map(int,input().split())
a=[]
for i in range(m):
    a.append(int(input()) )
from collections import deque
a=deque(a)
mod=10**9 + 7

dp=[0]*(n+2)
dp[0]=0
dp[1]=1
aa=a.popleft()
for i in range(2,n+2):
    if i-1 == aa:
        dp[i]=0
        if len(a)>0:
            aa=a.popleft()
    else:
        dp[i]=( dp[i-1]+dp[i-2] )%mod
print(dp[-1])

### FIXED CODE ###

#c dp version
n,m = map(int,input().split())
a=[]
for i in range(m):
    a.append(int(input()) )
from collections import deque
a=deque(a)
mod=10**9 + 7

dp=[0]*(n+2)
dp[0]=0
dp[1]=1
aa=0
if len(a)>0:
    aa=a.popleft()
for i in range(2,n+2):
    if i-1 == aa:
        dp[i]=0
        if len(a)>0:
            aa=a.popleft()
    else:
        dp[i]=( dp[i-1]+dp[i-2] )%mod
print(dp[-1])
N = input().split(" ")
TL = int(N[0])
TA = int(N[1])
AL = int(N[2])
AA = int(N[3])
a = 0

while a = 0:
  AL = AL - TA
  if AL <= 0:
    a = 1
    brake
  TA = TA - AA
  if TA <= 0:
    a = 2
    brake
if a = 1:
  print("Yes")
if a = 2:
  print("No")

### FIXED CODE ###

N = input().split(" ")
TL = int(N[0])
TA = int(N[1])
AL = int(N[2])
AA = int(N[3])
a = 0

while a == 0:
  AL = AL - TA
  if AL <= 0:
    a = 1
    break
  TL = TL - AA
  if TL <= 0:
    a = 2
    break
if a == 1:
  print("Yes")
elif a == 2:
  print("No")
N=int(input())
X=N/1.08
if X==int(X):
    print(int(X))
elif int(X*1.08)!=N:
    print(":(")
elif:
    ((int(X)+1)*1.08)==N:
        print(int(X)+1)
else:
    print(int(X))

### FIXED CODE ###

N=int(input())
X=int(N/1.08)
C=[X-1,X,X+1]
for c in C:
    d=int(c*1.08)
    if d==N:
        print(c)
        break
else:
    print(":(")
N = int(input())
K = int(input())
x = list(map(int,input().split()))
res = 0
for i in x:
  res += 2* min(x,K-x)
print(res)

### FIXED CODE ###

N = int(input())
K = int(input())
x = list(map(int,input().split()))
res = 0
for i in x:
  res += 2* min(i,K-i)
print(res)
n, m, k = map(int, input().split())
F = [[] for i in range(n)]
B = [set() for i in range(n)]
l = [0]*n

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

for i in range(k):
    c, d = map(int, input().split())
    B[c - 1].add(d - 1)
    B[d - 1].add(c - 1)

seen = [0]*n
cnt = 0
r = []

def dfs(x):
    if seen[x] == 0:
        r[cnt].add(x)
        seen[x] = 1
        for i in F[x]:
            dfs(i)

for i in range(n):
    if seen[i] == 0:
        r.append(set())
        dfs(i)
        cnt += 1

ans = [0]*n

for i in r:
    lr = len(i)
    for j in i:
        ans[j] = lr - len(F[j]) - len(i & B[j]) - 1

print(*ans)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**9)

n, m, k = map(int, input().split())
F = [[] for i in range(n)]
B = [set() for i in range(n)]
l = [0]*n

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

for i in range(k):
    c, d = map(int, input().split())
    B[c - 1].add(d - 1)
    B[d - 1].add(c - 1)

seen = [0]*n
cnt = 0
r = []

def dfs(x):
    if seen[x] == 0:
        r[cnt].add(x)
        seen[x] = 1
        for i in F[x]:
            dfs(i)

for i in range(n):
    if seen[i] == 0:
        r.append(set())
        dfs(i)
        cnt += 1

ans = [0]*n

for i in r:
    lr = len(i)
    for j in i:
        ans[j] = lr - len(F[j]) - len(i & B[j]) - 1

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

cnt = 0
for i in range(0, N, 2):
  if l[i] % 2 != 0:
    cnt += 1

print(cnt)

### FIXED CODE ###

L, R, d = map(int, input().split())
  
cnt = 0
for i in range(L, R+1, 1):
  if i % d == 0:
    cnt += 1

print(cnt)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import numpy as np

S = np.array(list(readline().rstrip()),np.int64)
T = np.array(list(readline().rstrip()),np.int64)

LS = len(S); LT = len(T)
LSext = LS + LT
LSext += (-LSext) % LS
Sext = np.tile(S,LSext//LS)

def cumprod(arr,MOD):
    L = len(arr); Lsq = int(L**.5+1)
    arr = np.resize(arr,Lsq**2).reshape(Lsq,Lsq)
    for n in range(1,Lsq):
        arr[:,n] *= arr[:,n-1]; arr[:,n] %= MOD
    for n in range(1,Lsq):
        arr[n] *= arr[n-1,-1]; arr[n] %= MOD
    return arr.ravel()[:L]

U = 10**6 + 100
base = 1234
MOD = 10**9 + 9
x = np.full(U,base,dtype=np.int64); x[0] = 1
power = cumprod(x,MOD)
x = np.full(U,pow(base,MOD-2,MOD),dtype=np.int64); x[0] = 1
power_inv = cumprod(x,MOD)

def RollingHash(S):
    return (S * power[:len(S)] % MOD).cumsum() % MOD

Sext_hash = RollingHash(Sext)
T_hash = RollingHash(T)[-1]

# ある地点を開始位置として、長さLTの文字列のhash値
x = Sext_hash[LT-1:LS+LT-1]
x[1:] -= Sext_hash[:LS-1]
x *= power_inv[:LS]; x %= MOD

# ある場所から始めたとして、Tを繰り返せる回数
cnt = [None] * LS
stack = np.where(x!=T_hash)[0].tolist()
if not stack:
    print(-1)
    exit()
for x in stack:
    cnt[x] = 0
while stack:
    x = stack.pop()
    y = (x-LT)%LS
    if cnt[y] is None:
        cnt[y] = cnt[x] + 1
        stack.append(y)

answer = max(cnt)
print(answer)

### FIXED CODE ###

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

S = input().rstrip()
T = input().rstrip()

S,T

# Sの方が長くする
LS = len(S)
LT = len(T)
n = (LT + (-LT) % LS) // LS
S *= (n+1)
S = S[:LS+LT]

MOD = 10 ** 16 + 61
base = 12345
base_inv = pow(base,MOD-2,MOD) 
power = [1] * (LS+LT)
power_inv = [1] * (LS+LT)
for n in range(1,LS+LT):
    power[n] = power[n-1] * base % MOD
    power_inv[n] = power_inv[n-1] * base_inv % MOD

def to_rolling_hash(S):
    ret = [0] * len(S)
    for i,s in enumerate(S):
        ret[i] = (ret[i-1] + power[i] * ord(s)) % MOD
    return ret

S_hash = to_rolling_hash(S) + [0]
T_hash = to_rolling_hash(T)[-1] # 文字列全体

can_start = [(S_hash[i + LT - 1] - S_hash[i - 1]) * power_inv[i] % MOD == T_hash for i in range(LS)]

INF = 10 ** 18
visited = [False] * LS
dp = [None] * LS

arr = [INF] * LS

q = [(i,0) for i,bl in enumerate(can_start) if not bl]

while q:
    qq = []
    for x,d in q:
        if arr[x] == INF:
            arr[x] = d
            qq.append(((x-LT)%LS, d+1))
    q = qq

answer = max(arr)

if answer >= INF:
    answer = -1

print(answer)
# -*- coding: utf-8 -*-
for i in range(1,10):
    for j in range(1,10):
        ans = i * j
        print(u"{0}×{1}={2}".format(i,j,ans))


### FIXED CODE ###

# -*- coding: utf-8 -*-
for i in range(1,10):
    for j in range(1,10):
        ans = i * j
        print str(i)+"x"+str(j)+ "=" +str(i*j)
        #print(u"{0}×{1}={2}".format(i,j,ans))
# -*- coding: utf-8 -*-
import itertools
N, K = map(int, input().split())
A = list(map(int, input().split()))
unnec = 0
for i in range(0,N):
    B = list(A)
    v = B.pop(i)
    nec = False
    for j in range(len(B),0,-1):
        for l in list(itertools.combinations(B,j)):
            s = sum(l)
            #print("%s, %d, %d" % (str(l), s, v))
            if s >= K:
                continue
            elif s + v >= K:
                nec = True
                break
        if nec == True:
            break
    if nec == False:
        unnec = unnec + 1
print(unnec)


### FIXED CODE ###

# -*- coding: utf-8 -*-
a, b = input().split()
if a == 'H':
    print(b)
else:
    if b == 'H':
        print('D')
    else:
        print('H')
def resolve():
    S = list(raw_input())
    S.sort()
    print "Yes" if S[0] == S[1] and S[2] == S[3] else "No"

### FIXED CODE ###

S = set(input())
print("Yes" if len(S) == 2 else "No")
a,b = list（input（）.split（））
c=int（a+b）
i=1
while True:
  if i *i ==c:
    print（"Yes"）
    exit（）
  elif i*i >c:
    print（"No"）
    exit（）
  else:
    i += 1

### FIXED CODE ###

a,b = list(input().split())
c=int(a+b)
i=1
while True:
  if i *i ==c:
    print("Yes")
    exit()
  elif i*i >c:
    print("No")
    exit()
  else:
    i += 1
a,b = list(input().split())
c=int(a+b)
i=1
while True:
  if i *i ==c:
    print("Yes")
    exit()
  elif i*i >c:
    print("No")
    exit()
  else:
    i += 1
def hantei(y,m):
    if str(y) == '00' or str(m) == '00':
        print('NA')
        if m > 12:
            print('YYMM')
        else:
            print('MMYY')
    else:
        print('AMBIGUOUS')


a = input()
b = 0
b1 = int(a[:2])
c2 = int(a[2:])
henkan(b1,c2)


### FIXED CODE ###

a = int(input())
y = a//100
m = a%100
if 1 <= y <= 12 and 1 <= m <= 12:
	print('AMBIGUOUS')
elif 1 <= y <= 12:
	print('MMYY')
elif 1 <= m <= 12:
	print('YYMM')
else:
	print('NA')
N = int(input())
ls = list(map(int,input().split()))
    
Pls = [0] * (10**6+1)

for i in ls:
    Pls[i] = 1

ii = 0
for j in range(len(Pls)):
    if Pls[j] == 0:
        continue
    else:
        ii += 1
        t = 2*j
        while t <= 10**6+1:
            Pls[t] = 0
            t += j

print(ii)

### FIXED CODE ###

N = int(input())
ls = list(map(int,input().split()))
    
Pls = [0] * (10**6+1)

for i in ls:
    Pls[i] += 1

ii = 0
for j in range(len(Pls)):
    if Pls[j] == 0:
        continue
    elif Pls[j] == 1:
        ii += 1
        t = 2*j
        while t <= 10**6:
            Pls[t] = 0
            t += j
    else:
        t = 2*j
        while t <= 10**6:
            Pls[t] = 0
            t += j

print(ii)
# 2019-11-28 02:28:10(JST)
import sys

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    return a * b // gcd(a, b)

def main():
    n, m = map(int, sys.stdin.readline().split())
    s, t = sys.stdin.read().split()

    g = gcd(n, m)
    l = lcm(n, m)

    if g == 1:
        if s[0] == s[1]:
            ans = l
    else:
        for i in range(g):
            if s[i * n // g] == t[i * m // g]:
                continue
            else:
                ans = -1
                break
        else:
            ans = l
    
    print(ans)

if __name__ == '__main__':
    main()


### FIXED CODE ###

# 2019-11-28 02:28:10(JST)
import sys

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    return a * b // gcd(a, b)

def main():
    n, m = map(int, sys.stdin.readline().split())
    s, t = sys.stdin.read().split()

    g = gcd(n, m)
    l = lcm(n, m)

    if g == 1:
        if s[0] == t[0]:
            ans = l
        else:
            ans = -1
    else:
        for i in range(g):
            if s[i * n // g] == t[i * m // g]:
                continue
            else:
                ans = -1
                break
        else:
            ans = l
    
    print(ans)

if __name__ == '__main__':
    main()
def have_ABC_string(n, str):
    count = 0
    for i in range(n):
        if str[i] == 'A' and str[i+1] == 'B' and str[i+2] == 'C':
            count += 1
    return count

N = int(input())
S = input()
result = have_ABC_string(N, S)
print(result)

### FIXED CODE ###

def have_ABC_string(n, str):
    count = 0
    for i in range(n-2):
        if str[i] == 'A' and str[i+1] == 'B' and str[i+2] == 'C':
            count += 1
    return count

N = int(input())
S = input()
result = have_ABC_string(N, S)
print(result)
n=int(input())
H=list(map(int,input().split()))
 
ans = 0
i = 0
cnt = 0
for i in range(N):
    if H[i] >= H[i+1]:
       cnt += 1
    else:
        ans = max(ans, cnt)
        cnt = 0
ans = max(ans, cnt)
print(ans)

### FIXED CODE ###

N=int(input())
H=list(map(int,input().split()))
 
ans = 0
i = 0
cnt = 0
for i in range(N-1):
    if H[i] >= H[i+1]:
       cnt += 1
    else:
        ans = max(ans, cnt)
        cnt = 0
ans = max(ans, cnt)
print(ans)
s = list(map(str,input().split()))

t = (list(s[1])).capitalize()

print(A + t + C)

### FIXED CODE ###

s = list(str(input()))
t = s[8].upper()
 
print('A' + t + 'C')
n=int(input())
if n%2==1:
	print(0)
else:
	n2=int(n/2)
	ans=0
	while n2>0:
		n2=int(n2/5)
		ans+=n2
print(ans)

### FIXED CODE ###

import sys
input = sys.stdin.readline

def main():
    n=int(input())
    cnt=5
    ans=0
    if n%2==0:
        n=n//2
        while cnt<=n:
            ans+=n//cnt
            cnt*=5
    print(ans)                
    
if __name__ == '__main__':
    main()
l = [int(i) for i in input().split()] 
ans = 0
 
for i in range(len(l) - 1):
	if l[i+1] < l[i]:
	tmp = l[i+1]
	l[i+1] = l[i]
	l[i] = tmp
    
for i in range(len(l) - 1):
	ans += l[i+1] - l[i]
    
print(ans)

### FIXED CODE ###

l = [int(i) for i in input().split()] 
ans = 0

for j in range(len(l) - 1):
	for i in range(len(l) - 1):
		if l[i+1] < l[i]:
			tmp = l[i+1]
			l[i+1] = l[i]
			l[i] = tmp
        
for i in range(len(l) - 1):
	ans += l[i+1] - l[i]
    
print(ans)
import sys
a = []
for l in sys.stdin:
    a.append(int(l))

if a[0] >= 3200:
    print(a[1])
else:
    print('red')

### FIXED CODE ###

import sys
a = []
for l in sys.stdin:
    a.append(l)

if int(a[0]) >= 3200:
    print(a[1])
else:
    print('red')
# -*- coding: utf-8 -*-
input_line_1 = raw_input()
fields = input_line_1.split()
N = fields[0]
A = fields[1]
B = fields[2]
T = A + B
all = raw_input()
for every in all:
	if every == 'c':
		print 'No'
	elif every == 'a':
		if T > 0:
			T = T - 1
			print 'Yes'
		else:
			print 'No'
	else:
		if T > 0 and B > 0:
			T = T - 1
			B = B - 1
			print 'Yes'
		else:
			print 'No'

### FIXED CODE ###

# -*- coding: utf-8 -*-
input_line_1 = raw_input()
fields = input_line_1.split()
N = int(fields[0])
A = int(fields[1])
B = int(fields[2])
T = A + B
all = raw_input()
for every in all:
	if every == 'c':
		print 'No'
	elif every == 'a':
		if T > 0:
			T = T - 1
			print 'Yes'
		else:
			print 'No'
	else:
		if T > 0 and B > 0:
			T = T - 1
			B = B - 1
			print 'Yes'
		else:
			print 'No'
a, b = [int(x) for x in input().split()]
print(max(a + b, a - b, a * b)

### FIXED CODE ###

a, b = [int(x) for x in input().split()]
print(max(a + b, a - b, a * b ))
n=int(input())
arr=[int(x) for x in input().split(' ')]
total=sum(arr)
temp=0
ans=1000
for item in arr:
  temp+=item
  a=total-temp
  ans=min(ans,abs(a-temp))
print(ans)

### FIXED CODE ###

p,q,r=[int(x) for x in input().split(' ')]
print(min(p+q,q+r,p+r))
import heapq

def dijkstra(nodes, N):
    dist = [float('inf') for i in range(N + 2)]
    prev = [float('inf') for i in range(N + 2)]

    dist[0] = 0
    q = []
    heapq.heappush(q, (0, 0))

    while len(q) != 0:
        prov_cost, src = heapq.heappop(q)
        if dist[src] < prov_cost:
            continue

        for (nextnum, dis) in nodes[src].nextnode:
            cost = dis
            if dist[nextnum] >= dist[src] + cost:
                dist[nextnum] = dist[src] + cost
                heapq.heappush(q, (dist[nextnum], nextnum))
                prev[nextnum] = src
        
    return get_path(N + 1, prev)

def get_path(goal, prev):
    path = [goal]
    dest = goal

    while prev[dest] != float('inf'):
        path.append(prev[dest])
        dest = prev[dest]

    return list(reversed(path))

class People:
    def __init__(self, num):
        self.nodenum = num
        self.nextnode = []

    def set_node(self, num, dis):
        self.nextnode.append((num, dis))

    def node_adj(self):
        if self.nextnode == []:
            self.nextnode.append((self.nodenum + 1, 0))


N, M = (int(i) for i in input().split())  

nodes = []
for i in range(N+2):
    nodes.append(People(i))

for i in range(M):
    L, R, D = (int(i) for i in input().split())
    nodes[L].set_node(R, D)

for i in range(N+1):
    nodes[i].node_adj()

ans = dijkstra(nodes, N)

flag = True
for i in range(N+1):
    if ans[i] != i:
        flag = False
if flag:
    print('Yes')
else:
    print('No')

### FIXED CODE ###



def dfs(graph, start, visited):
    if visited[start] != -99999:
        return True
    
    stack = [start]
    visited[start] = 0
    while stack:
        label = stack.pop()
        for nextnode, distance in graph[label]:
            if visited[nextnode] == -99999:
                stack.append(nextnode)
                visited[nextnode] = visited[label] + distance
            elif visited[nextnode] != visited[label] + distance:
                return False
    return True

N, M = (int(i) for i in input().split())  

graph = [[] for i in range(N+1)]

for i in range(M):
    L, R, D = (int(i) for i in input().split())
    graph[L].append((R, D))
    graph[R].append((L, -1 * D))


visited = [-99999 for i in range(N+1)]

flag = True
for i in range(1, N + 1):
    ans = dfs(graph, i, visited)
    if not ans:
        flag = False
        break

if flag:
    print('Yes')
else:
    print('No')
n = int(input())
flowers = list(map(int, input().split()))
flowers.append(max(flowers))
cnt = 0
for i in range(sum(flowers)):
    if(all([x<0 for x in flowers])): break
    print(flowers, i, cnt)
    flowers = list(map(lambda x: (x-1), flowers))
    for j in range(n):
        if(flowers[j] > 0 and flowers[j+1] <= 0): cnt+=1
print(i + cnt)

### FIXED CODE ###

n = int(input())
flowers = list(map(int, input().split()))
flowers.append(0)
cnt = 0
if(all([x<=0 for x in flowers])): print(0)
else: 
    for i in range(sum(flowers)+1):
        #print(i)
        if(all([x<=0 for x in flowers])): break
        #print(flowers, i, cnt)
        for j in range(n-2):
            if(flowers[j] > 0 and flowers[j+1] <= 0 and any([x>0 for x in flowers[j+2:]])): cnt+=1
        flowers = list(map(lambda x: (x-1), flowers))
    print(i + cnt)
import numpy as np
N = int(input())
h = list(map(int, input().split()))
default = np.inf
dp = [default] * N

def rec(i):
  if dp[i] != default:
    return dp[i]
  if i == 0:
    dp[i] = 0
    return 0
  dp[i] = min(dp[i], rec(i-1)+np.abs(h[i] - h[i-1]))
  if i >= 2:
    dp[i] = min(dp[i], rec(i-2)+np.abs(h[i] - h[i-2]))
  return dp[i]
print(int(rec(N-1)))

### FIXED CODE ###

import numpy as np
N = int(input())
h = list(map(int, input().split()))
dp = [9999] * N
dp[0] = 0
for i in range(1,N):
  if i<2:
    dp[i] = dp[i-1] + np.abs(h[i] - h[i-1])
  else:
    min1 = dp[i-2] + np.abs(h[i] - h[i-2])
    min2 = dp[i-1] + np.abs(h[i] - h[i-1])
    dp[i] = min(min1, min2)
print(dp[N-1])
a

### FIXED CODE ###

a, b, c, d = map(int, input().split())
if a / 2 == c and b / 2 == d:
    print(str(a * b / 2) + " " + "1")
else:
    print(str(a * b / 2) + " " + "0")