Harryxun/stf_run huggingface dataset:
a = int(input().split()[0])
alle = []
counter = 0
output = []
for i in range(a):
	p = input().split()
	p = [int(j)%2 for j in p]
	if len(p) >= 1:
		for j in range(len(p) - 1):
			if p[j] % 2 == 1:
				output.append([i + 1, j + 1, i + 1, j + 2])
				counter += 1
				p[j + 1] += 1
		alle.append(p[-1])
	else:
		alle.append(p)
	
for i in range(a - 1):
	if (len(p) > 1):
		if alle[i] % 2 == 1:
			output.append([i + 1, len(p[0]),  i + 2, len(p[0])])
			counter += 1
			alle[i + 1] = alle[i] + 1
	else:
		if alle[i] % 2 == 1:
			output.append([i + 1, 1,  i + 2, 1])
			counter += 1
			alle[i + 1] = alle[i] + 1
		
print (counter)
for i in output:
	print (i[0],i[1],i[2],i[3])

### FIXED CODE ###

a = int(input().split()[0])
alle = []
counter = 0
output = []
for i in range(a):
	p = input().split()
	p = [int(j)%2 for j in p]
	for j in range(len(p) - 1):
		if p[j] % 2 == 1:
			output.append([i + 1, j + 1, i + 1, j + 2])
			counter += 1
			p[j + 1] += 1
	alle.append(p[-1])
	
for i in range(a - 1):
	if alle[i] % 2 == 1:
		output.append([i + 1, len(p),  i + 2, len(p)])
		counter += 1
		alle[i + 1]  += 1
		
print (counter)
for i in output:
	print (i[0],i[1],i[2],i[3])
n,a, b = map(int, input().split())
    l = []
    for i in range(10 ^100):
        l.extend([1]*a)
        l.extend([0]*b)
    
    print(sum(l[:n]))

### FIXED CODE ###

n,a, b = map(int, input().split())
ans = n //(a+b) *a
tmp = n%(a+b)
ans += min(tmp,a)
print(ans)
a,b,c=input()

print(c,a,b)

### FIXED CODE ###

a,b,c=input().split()

print(c,a,b)
a = input()
if a == "Sunny":
  print("Cloudy")
elif a == 'Cloudy':
  print('Rainy'):
elif a == 'Rainy':
  print('Sunny')

### FIXED CODE ###

a = input()
if a == "Sunny":
  print("Cloudy")
elif a == 'Cloudy':
  print('Rainy')
elif a == 'Rainy':
  print('Sunny')
a=int(input());b=str(input());c=int(input())

if b=='+':
  print(a+c)
else:
  print(a-c)
  

### FIXED CODE ###

a,b,c=input().split(' ')

if b=='+':
  print(int(a)+int(c))
else:
  print(int(a)-int(c))
N, M = map(int, input().split())

city = [[0] * 100000 for j in range(N)]
citynum = [0] * 100000
citynum_ = [0] * 100000

for i in range(M):
    p, y = map(int, input().split())
    city[p-1][y] = i+1
    citynum[i+1] = p
    citynum_[i+1] = y

rank = [[0] * 100000 for j in range(N)]

for i in range(N):
    count = 0
    for j in range(100000):
        if city[i][j] != 0:
            count += 1
            rank[i][j] = count

citynum2 = [0] * 100000

for i in range(M):
    citynum2[citynum[i+1]] += 1
    ansp = citynum[i+1]
    ansy = rank[ansp-1][citynum_[i+1]]

    print('{:06}'.format(ansp)+'{:06}'.format(ansy))


### FIXED CODE ###

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

ypi = []

for i in range(M):
    p, y = map(int,input().split())
    ypi.append([y, p, i])

ypi.sort()

rank = [0] * N

ans = [''] * M
for count in range(M):
    y, p, i = ypi[count]
    rank[p-1] += 1
    ans[i] = '{:06}'.format(p)+'{:06}'.format(rank[p-1])

for s in ans:
    print(s)
x = list(map(int, input().split())
x.sort()
print(" ".join(map(str, x)))



### FIXED CODE ###

x = list(map(int, input().split()))
x.sort()
print(" ".join(map(str, x)))
# coding: utf-8
# Your code here!

def Bellman_Ford(g,start):
    n = len(g)    
    dist = [float("inf")]*n
    dist[start] = 0
    a0 = float("inf")
    negative = [False]*n
    for i in range((2*n)):
        updated = False
        for v in range(n):
            for to, cost in g[v]:
                if negative[v]: negative[to] = True
                if dist[to] <= dist[v] + cost: continue
                dist[to] = dist[v] + cost
                updated = True
                if i >= n:
                    negative[to] = True
        if not updated: break
    if negative[-1]: return None, False
    return dist, True
 

import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意

n,m,p = [int(i) for i in readline().split()]
g = [[] for _ in range(n)]
for i in range(m):
    a,b,c = [int(i) for i in readline().split()]
    g[a-1].append((b-1,-c+p))
#    g[b-1].append((a-1,c))

dist, TF = Bellman_Ford(g, 0)

if TF: print(max(-dist[-1],0))
else: print(-1)


assert n!=3 and m!=3 and p !=10

### FIXED CODE ###

# coding: utf-8
# Your code here!

def Bellman_Ford(g,start):
    n = len(g)    
    dist = [float("inf")]*n
    dist[start] = 0
    a0 = float("inf")
    
    for i in range(n<<1):
        updated = False
        for v in range(n):
            for to, cost in g[v]:
                if dist[to] <= dist[v] + cost: continue
                dist[to] = dist[v] + cost
                updated = True
        if not updated: break
        if i <= n: a0 = dist[-1]
    if a0 != dist[-1]: return None, False
    return dist, True


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意

n,m,p = [int(i) for i in readline().split()]
g = [[] for _ in range(n)]
for i in range(m):
    a,b,c = [int(i) for i in readline().split()]
    g[a-1].append((b-1,-c+p))
#    g[b-1].append((a-1,c))

dist, TF = Bellman_Ford(g, 0)

if TF: print(max(-dist[-1],0))
else: print(-1)
n = int(input())
money = 0
for _ in range(n):
  p = input().split()
  if p[1] == 'JPY':
    money += int(p[0])
  elif p[1] == 'BTC':
    money += int(p[0]) * 380000

print(money)

### FIXED CODE ###

n = int(input())
money = 0
for _ in range(n):
  p = input().split()
  if p[1] == 'JPY':
    money += int(p[0])
  elif p[1] == 'BTC':
    money += float(p[0]) * 380000

print(money)
line = input().split()
x = int(line[1])
ans = 0
 
a = sorted(input().split())
[map(int, a[i]) for i in len(a)]
 
for i in range(len(a)):
  if a[i] > x:
    print(ans)
    break
  else:
    x-=a[i]
    if i!=(len(a)-1):
      ans+=1
    else:
      if x==0:
        ans+=1
      print(ans)

### FIXED CODE ###

line = input().split()
N = int(line[0])
x = int(line[1])
ans = 0

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

for i in range(N):
    if a[i] > x:
        print(ans)
        break
    else:
        x -= a[i]
        if i != (N - 1):
            ans += 1
        else:
            if x == 0:
                ans += 1
            print(ans)
a, b = map(int, input().split())
s = a * b
l = a * 2 + b * 2
print(s + " " + l)


### FIXED CODE ###

a, b = map(int, input().split())
s = a * b
l = a * 2 + b * 2
print(str(s) + " " + str(l))
#!/usr/bin/env python3

import sys
import math
import itertools

def required_visit_time(t, shop):
    a, b = shop
    return int((t - b) / (a + 1)) - 1

# shops はソート済み
def calc_dp_time(T, shops):
    t = T
    for s in shops:
        t = required_visit_time(t, s)
    return t

def main():
    N, T = map(int, sys.stdin.readline().split())
    shops = list(tuple(map(int, sys.stdin.readline().split())) for _ in range(N))

    shops.sort(key=lambda x: x[0] / (x[0] + x[1] + 1), reverse=True)
    dpmemo = {}

    def dp(i, t):
        assert i >= 0
        assert t >= 0

        if i == 0:
            return 0

        if (i, t) in dpmemo:
            return dpmemo[i, t]

        h = i - 1
        r = required_visit_time(t, shops[h])
        n = max(dp(h, r) + 1, dp(h, t)) if r >= 0 else dp(h, t)
        dpmemo[i, t] = n
        return n

    dpmax = sum(1 for _ in itertools.takewhile(lambda x: x[0] > 0, shops))

    # dp(dpmax, t) | t = T と同じ値を得られる最小の t を二分探索
    ans = dp(dpmax, T)
    l = 0
    r = T + 1
    while l + 1 < r:
        m = int((l + r) / 2)
        n = dp(dpmax, m)
        if n < ans:
            l = m
        else:
            r = m

    t = r
    for i in range(dpmax, N):
        _, b = shops[i]
        t += 1 + b
        if t > T:
            break
        ans += 1

    print(ans)

if __name__ == '__main__':
    main()

### FIXED CODE ###

#!/usr/bin/env pypy3

import sys
import math
import itertools
import bisect

INF = int(1e18)
T_MAX = int(1e9)

def main():
    N, T = map(int, sys.stdin.readline().split())
    shops = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N)]

    nzshops = [(a, b) for a, b in shops if a > 0]
    zshops  = [(a, b) for a, b in shops if a == 0]

    nzshops.sort(key=lambda x: x[0] / (x[0] + x[1] + 1), reverse=True)
    zshops.sort()

    dp = [[0] + [INF] * int(math.log(T_MAX, 2)) for _ in range(len(nzshops) + 1)]
    for i in range(1, len(dp)):
        for c in range(1, len(dp[i])):
            a, b = nzshops[i - 1]
            t = dp[i - 1][c - 1] + 1
            dp[i][c] = min(dp[i - 1][c], t + t * a + b)

    rs = list(itertools.accumulate(1 + b for _, b in zshops))
    ans = max(c + bisect.bisect(rs, T - dp[-1][c])
            for c in range(len(dp[-1])) if dp[-1][c] <= T)

    print(ans)

if __name__ == '__main__':
    main()
a,b = map(int,input().split())
 
s = a + b
if s % 2 = 1:
  s = s+ 1
  
print(s // 2)

### FIXED CODE ###

l = list(map(int,input().split()))
 
s = l[0] + l[1]
if s % 2 == 1:
    s = s+ 1
else:
    None
print(s // 2)
N, D, A = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]

class BIT:
    def __init__(self, n=None):
        # 1-index
        if n is None:
            n = (1 << 18) - 1
        self.n = n
        self.dat_a = [0] * (2 * self.n - 1)
        self.dat_b = [0] * (2 * self.n - 1)

    def add(self, a, b, x, k=0, l=0, r=None):
        # Add x to [a, b)
        if r is None:
            r = self.n

        if a <= l and r <= b:
            self.dat_a[k] += x
        elif l < b and a < r:
            self.dat_b[k] += (min(b, r) - max(a, l)) * x
            self.add(a, b, x, k * 2 + 1, l, (l + r) // 2)
            self.add(a, b, x, k * 2 + 2, (l + r) // 2, r)
            
    def query(self, a, b, k=0, l=0, r=None):
        # Retrun sum of [a, b)
        if r is None:
            r = self.n
        
        if b <= l or r <= a:
            return 0
        
        if a <= l and r <= b:
            return self.dat_a[k] * (r - l) + self.dat_b[k]
        
        res = (min(b, r) - max(a, l)) * self.dat_a[k]
        res += self.query(a, b, k * 2 + 1, l, (l + r) // 2)
        res += self.query(a, b, k * 2 + 2, (l + r) // 2, r)
        
        return res


ans = 0
bit = BIT()
X.sort(key=lambda x:x[0] - x[1])
for x, h in X:
    res = h - bit.query(x, x + 1)
    if res <= 0:
        continue
        
    cnt = -(-res // A)
    bit.add(x, x + 2 * D + 1, cnt * A)
    ans += cnt
    
print(ans)




### FIXED CODE ###

import bisect

N, D, A = map(int, input().split())
XH = [list(map(int, input().split())) for _ in range(N)]

XH.sort()
X, H = zip(*XH)

K = [-(-h // A) for h in H]
L = [0] * (N + 2)

ans = 0
for i in range(N):
    L[i + 1] += L[i]
    s = max(K[i] - L[i + 1], 0)
    ans += s
    L[i + 1] += s
    L[bisect.bisect_right(X, X[i] + 2 * D) + 1] -= s

print(ans)
A, B, C, X, Y = map(int, input().split())
not_in_C = A*X + B*Y
if X > Y:
  cost = 2 * C * Y 
  if A < C:
    cost += A * (X - Y)
  else:
    cost += 2 * C * (X - Y)
elif X < Y
  cost = 2 * C * X
  if B < C:
    cost += B * (Y - X)
  else:
    cost += 2 * C * (Y - X)
elif X == Y:
  cost = 2 * C * Y
print(min(not_in_C, cost))

### FIXED CODE ###

A, B, C, X, Y = map(int, input().split())
cost = A*X + B*Y
new_cost = cost
plus = 0
for i in range(1, max(X, Y)+1):
  if i <= min(X, Y):
    plus = - A - B + 2*C
  else:
    plus = -A + 2*C if X > Y else -B + 2*C
  if plus < 0:
    new_cost += plus
  else:
    break
print(new_cost)
_ = input()
a=map(int,*input().split())
flag = True
for i in a:
  if i%2 == 0:
    if i%3 != 0:
      if i%5 != 0:
        flag = False
        break
if flag:
  print("APPROVED")
else:
  print("DENIED")

### FIXED CODE ###

_ = input()
a=map(int,input().split())
flag = True
for i in a:
  if i%2 == 0:
    if i%3 != 0:
      if i%5 != 0:
        flag = False
        break
if flag:
  print("APPROVED")
else:
  print("DENIED")
n=int(input())
dic={"AC":0,"WA":0,"TLE":0,"RE":0}
for _ in range(n):
  s=input()
  dic[s]+=1
for k,v in dic.items():
  print("{0} x {1}".format(k,v)

### FIXED CODE ###

n=int(input())
dic={"AC":0,"WA":0,"TLE":0,"RE":0}
for _ in range(n):
  s=input()
  dic[s]+=1
for k,v in dic.items():
  print("{0} x {1}".format(k,v))
n = int(input())
a = list(map(int, input().split()))
arrays = []
a.sort()

b = []
c = []

for i in a:
    if i < 0:
        c.append(i)
    else:
        b.append(i)

if len(c) >= 1:
    while len(b) > 1:
        x = b.pop(0)
        array = [c[0], x]
        c[0] -= x
        arrays.append(array)

    array = [b[0], c[0]]
    arrays.append(array)

    print(b[0] - c[0])

else:
    mi = b.pop(0)
    while len(b) > 1:
        x = b.pop(0)
        array = [mi, x]
        mi -= x
        arrays.append(array)
    array = [b[0], mi]
    arrays.append(array)
    print(b[0]-mi)


for x, y in arrays:
    print(x, y)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
arrays = []
a.sort()

b = []
c = []

for i in a:
    if i < 0:
        c.append(i)
    else:
        b.append(i)

if len(c) >= 1 and len(b) >= 1:
    while len(b) > 1:
        x = b.pop(0)
        array = [c[0], x]
        c[0] -= x
        arrays.append(array)
    while len(c) > 1:
        y = c.pop(0)
        array = [b[0], y]
        b[0] -= y
        arrays.append(array)

    array = [b[0], c[0]]
    arrays.append(array)

    print(b[0] - c[0])

elif len(b) == 0 and len(c) >= 1:
    mi = c.pop(-1)
    while len(c) > 1:
        x = c.pop(0)
        array = [mi, x]
        mi -= x
        arrays.append(array)
    array = [mi, c[0]]
    arrays.append(array)
    print(mi - c[0])


elif len(b) >= 1 and len(c) == 0:
    mi = b.pop(0)
    while len(b) > 1:
        x = b.pop(0)
        array = [mi, x]
        mi -= x
        arrays.append(array)
    array = [b[0], mi]
    arrays.append(array)
    print(b[0]-mi)


for x, y in arrays:
    print(x, y)
n = int(input())
k = int(input())
h = int(input())
a = []
if h >= k:
	a.append(str(h))
print(len(a))

### FIXED CODE ###

import random
n = int(input())
x = random.randint(1,n)
if n % 2 ==0:
  print(0.5)
else:
  count = n//2
  print((n-count)/n)
N,K=map(int,input().split())
if N%K==0:
    print(0)
    exit()
if N<K:
    print(N)
    exit()
ans=N%K
if ans>=abs(ans-K):
    print(abs(ans-K))
else:
    print(ans)

### FIXED CODE ###

X,Y,Z=map(str,input().split())
print(Z+' '+X+' '+Y)
#!/usr/bin/env python3.4
# -*- coding: utf-8 -*-

# abc126_d

from collections import namedtuple

DistFrom = namedtuple('DistFrom', ['f', 'dist'])

def main():
    # input
    n, = [int(s) for s in input().split()]
    #if n==1: return
    fs = [[int(s) for s in input().split()] for _ in range(n-1)]
    # getans
    gs = [None] * n
    for i in range(n):
        gs[i] = list()
    for x, y, d in fs:
        x -= 1
        y -= 1
        d = d%2
        gs[x].append(DistFrom(y, d))
        gs[y].append(DistFrom(x, d))
    distlist = [None] * n
    def search(cur, prev, dist):
        #distlist[cur] != None: return
        distlist[cur] = dist
        for i, d in gs[cur]:
            if i != prev:
                search(i, cur, dist^d)
    distlist[0] = 0
    for i, d in gs[0]:
        search(i, 0, d)
    ans = distlist
    # output
    for a in ans:
        print(a)

if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
 
sys.setrecursionlimit(10**5)

n = int(input())
p = [list() for _ in range(n)]
for i in range(n-1):
    u, v, w = [int(s) for s in input().split()]
    u -= 1
    v -= 1
    w %= 2
    p[u].append((v, w))
    p[v].append((u, w))

costs = [-1 for _ in range(n)]

def dfs(cur, dist):
    if costs[cur] != -1:
        return
    costs[cur] = dist
    for v, d in p[cur]:
        dfs(v, dist^d)
dfs(0, 0)

for i in range(n):
    print(costs[i])
n, q = map(int, input().split())
connect = [[] for _ in range(n)]
for _ in range(n-1):
    a, b = map(int, input().split())
    connect[a - 1].append(b-1)
    connect[b - 1].append(a - 1)
    
values = [0] * n
for _ in range(q):
    p, x = map(int, input().split())
    values[p - 1] += x

def dfs(parent, flags, add_num):
    for num in connect[parent]:
        if flags[num]:
            add_num += values[num]
            result[num] = add_num
            flags[num] = 0
            dfs(num, flags, add_num)
            add_num -= values[num]
result = [0] * n
result[0] = values[0]
flags = [1] * n
flags[0] = 0
add_num = values[0]
dfs(0, flags, add_num)
print(' '.join(str(i) for i in result))

### FIXED CODE ###

n, q = map(int, input().split())
connect = [[] for _ in range(n)]
for _ in range(n-1):
    a, b = map(int, input().split())
    connect[a - 1].append(b-1)
    connect[b - 1].append(a - 1)
    
values = [0] * n
for _ in range(q):
    p, x = map(int, input().split())
    values[p - 1] += x

from collections import deque
que = deque([[-1, 0]])
while que:
    parent, child = que.popleft()
    for num in connect[child]:
        if num == parent:
            continue
        values[num] += values[child]
        que.append([child, num])
print(*values)
while True:
    x,y = map(int, input().split())
    if x == 0 and y == 0:
        continue
    if x => y:
        print (y,x)
    else:
        print (x,y)

### FIXED CODE ###

while True:
    x,y = map(int, input().split())
    if x == 0 and y == 0 :
        break
    elif x <= y :
        print (x,y)
    else :
        print (y,x)
n,k = map(int,input().split())
x = [int(_) for _ in input().split()]
res = 0
for i in range(n):
  res += min(x[i],abs(k-x[i]))
print(res*2)

### FIXED CODE ###

n = int(input())
k = int(input())
x = [int(_) for _ in input().split()]
res = 0
for i in range(n):
  res += min(x[i],abs(k-x[i]))
print(res*2)
while True:
 result = 0
 i = input().split()
 if i[1] == '+':
  result = int(i[0]) + int(i[2])
 elif i[1] == '-':
  result = int(i[0]) - int(i[2])
 elif i[1] == '*':
  result = int(i[0]) * int(i[2])
 elif i[1] == '/':
  result = int(i[0]) / int(i[2])
 print('{0}\n'.format(result))

### FIXED CODE ###

while True:
 result = 0
 i = input().split()
 if i[1] == '+':
  result = int(i[0]) + int(i[2])
 elif i[1] == '-':
  result = int(i[0]) - int(i[2])
 elif i[1] == '*':
  result = int(i[0]) * int(i[2])
 elif i[1] == '/':
  result = int(i[0]) // int(i[2])
 elif i[1] == '?':
  break
 print(result)
class UnionFind():
  def __init__(self,n):
    self.parents = list(range(n))
    self.size = [1]*n
  
  def find(self,x):
    if self.parents[x] == x:
      return x
	
    self.parents[x] = self.find(self.parents[x])
    return self.parents[x]
  
  def union(self,x,y):
    x = self.find(x)
    y = self.find(y)
    
    if x==y:
      return
    
    if self.size[x]>self.size[y]:
      x,y=y,x
	
    self.size[x]+=self.size[y]
    self.parents[y] = x
  
  def sizeofset(self,x):
    return self.size[self.find(x)]


N,M=map(int,input().split())
uf = UnionFind(N+1)

cnt=(N)*(N-1)//2
L=[[int(x) for x in input().split()] for _ in range(M)]
ans=[]

for a,b in L[::-1]:
  ans.append(cnt)
  if uf.find(a)!=uf.find(b):
    cnt-= uf.sizeofset(a)*uf.sizeofset(b)
    uf.union(a,b)

for x in ans[::-1]:
  print(x)

### FIXED CODE ###

class UnionFind():
  def __init__(self,n):
    self.parents = list(range(n))
    self.size = [1]*n
  
  def find(self,x):
    if self.parents[x] == x:
      return x
	
    self.parents[x] = self.find(self.parents[x])
    return self.parents[x]
  
  def union(self,x,y):
    x = self.find(x)
    y = self.find(y)
    
    if x==y:
      return
    
    if self.size[x]<self.size[y]:
      x,y=y,x
	
    self.size[x]+=self.size[y]
    self.parents[y] = x
  
  def same(self,x,y):
    return self.find(x) == self.find(y)
  
  def sizeofset(self,x):
    return self.size[self.find(x)]


N,M=map(int,input().split())
uf = UnionFind(N+1)

cnt=(N)*(N-1)//2
L=[[int(x) for x in input().split()] for _ in range(M)]
ans=[]

for a,b in L[::-1]:
  ans.append(cnt)
  if not uf.same(a,b):
    cnt -= uf.sizeofset(a)*uf.sizeofset(b)
    uf.union(a,b)

for x in ans[::-1]:
  print(x)
num = int(input())
print(num**3)

### FIXED CODE ###

num = int(input())
print(num**3)
def lcs():
???x = raw_input()
  y = raw_input()
???x_len = len(x)
  y_len = len(y)
  z2 = [0 for i in range(y_len+1)]

  for i in range(x_len):
    z1 = z2 + []
    ele = x[i]
    for k in range(y_len):
      if ele == y[k]:
         z2[k+1] = z1[k] + 1
      elif z2[k+1] < z2[k]:???
?????????   z2[k+1] = z2[k]

  return z2[-1]

num = input()
for l in range(num):
  print lcs()

### FIXED CODE ###

def lcs():
  x = raw_input()
  y = raw_input()
  x_len = len(x)
  y_len = len(y)
  z2 = [0 for i in range(y_len+1)]

  for i in range(x_len):
    z1 = z2 + []
    ele = x[i]
    for k in range(y_len):
      if ele == y[k]:
        z2[k+1] = z1[k] + 1
      elif z2[k+1] < z2[k]:
        z2[k+1] = z2[k]

  return z2[-1]

num = input()
for j in range(num):
  print lcs()
N=int(input())

flag=0
for h in range(1,3501):
  if flag==1:
      break:  
  for n in range(h,3501):
    if flag==1:
      break:
    else:
      val=4*h*n-n*N-h*N
      if val != 0:
        w=N*h*n/val
        if int(w)==w and w > 0:
          print(h,n,int(w))
          flag=1
        
        


### FIXED CODE ###

N=int(input())

flag=0
for h in range(1,3501):
  for n in range(h,3501):
    if flag==0:
      val=4*h*n-n*N-h*N
      if val != 0:
        w=N*h*n/val
        if int(w)==w and w > 0:
          print(h,n,int(w))
          flag=1
s = input()
a = len(s)
print("x" * s)

### FIXED CODE ###

s = input()
a = len(s)
print("x" * a)
size = int(input())
nums = list(map(int, input().split()))

# size = 3
# nums = [0, 0, 0]

if size % 3 != 0:
  print("No")
  quit()

numu = list(set(nums))
if len(numu) == 1 and numu[0] == 0:
  print("Yes")
  quit()

if len(numu) == 2 and numu.count(0) > 0:
  print("Yes")
  quit()


num = nums.count(numu[0])
if nums.count(nums[1]) != num or nums.count(nums[2]) != num:
  print("No")
  quit()

if numu[0] ^ numu[2] == numu[1] \
    and numu[1] ^ numu[0] == numu[2] \
    and numu[2] ^ numu[1] == numu[0]:
  print("Yes")
  quit()

print("No")




### FIXED CODE ###

size = int(input())
nums = list(map(int, input().split()))
# 
# size = 6
# nums = [0, 2, 2, 0, 2, 2]

numu = list(set(nums))
if len(numu) == 1 and numu[0] == 0:
  print("Yes")
  quit()


if len(numu) == 2 \
    and nums.count(0) != 0 \
    and nums.count(0) * 3 == size:
  print("Yes")
  quit()

if len(numu) == 3:
  if nums.count(0) == 1:
    print("No")
    quit()

  if not nums.count(numu[0]) == nums.count(numu[1]) == nums.count(numu[2]):
    print("No")
    quit()

  if numu[0] ^ numu[2] == numu[1] \
      and numu[1] ^ numu[0] == numu[2] \
      and numu[2] ^ numu[1] == numu[0]:
    print("Yes")
    quit()

print("No")
#include<iostream>
using namespace std;

int main(){
    int a;
    cin>>a;
    cout<<(a+2-1)/2<<endl;
    return 0;

}

### FIXED CODE ###

print((int(input())+1)//2)
size = int(input())
nums = list(map(int, input().split()))

# size = 4
# nums = [1, 2, 3, 1, 2, 3]

numu = list(set(nums))
if size % 3 != 0:
  print("No")
  quit()

num = nums.count(numu[0])
if nums.count(nums[1]) != num or nums.count(nums[2]) != num:
  print("No")
  quit()

if numu[0] ^ numu[2] == numu[1] \
    and numu[1] ^ numu[0] == numu[2] \
    and numu[2] ^ numu[1] == numu[0]:
  print("Yes")
  quit()

print("No")


### FIXED CODE ###

size = int(input())
nums = list(map(int, input().split()))
# 
# size = 6
# nums = [0, 2, 2, 0, 2, 2]

numu = list(set(nums))
if len(numu) == 1 and numu[0] == 0:
  print("Yes")
  quit()


if len(numu) == 2 \
    and nums.count(0) != 0 \
    and nums.count(0) * 3 == size:
  print("Yes")
  quit()

if len(numu) == 3:
  if nums.count(0) == 1:
    print("No")
    quit()

  if not nums.count(numu[0]) == nums.count(numu[1]) == nums.count(numu[2]):
    print("No")
    quit()

  if numu[0] ^ numu[2] == numu[1] \
      and numu[1] ^ numu[0] == numu[2] \
      and numu[2] ^ numu[1] == numu[0]:
    print("Yes")
    quit()

print("No")
(A, V) = input().split()
(B, W) = input().split()
T = input()

D = abs(A - B)
X = abs(x - Y)

if X*T >= D:
  print("OK")
else:
  print("NG")

### FIXED CODE ###

(A, V) = map(lambda a: float(a), input().split())
(B, W) = map(lambda a: float(a), input().split())
T = float(input())

D = abs(A - B)
X = V - W

if (X*T >= D):
  print("YES")
else:
  print("NO")