Harryxun/stf_run huggingface dataset:
from sys import stdin
from math import sqrt,fabs


class Ufo:
	def __init__(self,x,y,r,v):
		self.x = x*1.0
		self.y = y*1.0
		self.r = r*1.0
		self.v = v*1.0
		self.d = sqrt(x**2+y**2)
		self.cs = self.x / self.d
		self.si = self.y / self.d
		self.vx = -self.v*self.cs
		self.vy = -self.v*self.si
		self.migigawa = (self.x > 0)

	def __str__(self):
		return "ufo x = " + str(self.x) + ", y = " + str(self.y) + ", r = " + str(self.r) + ", v = " + str(self.v)

	def invaded(self):
		global R
		return (self.d<= R)

	def oneMinMove(self):
		self.x += self.vx
		self.y += self.vy
		self.d -= self.v

class Laser():
	def __init__(self,cs,si,migigawa):
		self.cs = cs
		self.si = si
		self.migigawa = migigawa

def hit(laser,ufo):
	if laser.migigawa == ufo.migigawa: 
		return (fabs(laser.si*ufo.x - laser.cs*ufo.y) <= ufo.r)
	else:
		return False


def gameOneMinMove():
	global ufos
	global gameend
	global inrl
	curInrs = []
	for ufo in ufos:
		ufo.oneMinMove()
		if ufo.invaded(): curInrs.append(ufo)
	inrl += len(curInrs)
	#print str(len(curInrs)) + " ufos invaded!"
	for ufo in curInrs:
		ufos.remove(ufo)
		#print ufo
	del curInrs
	if ufos == []:
		gameend = True

def setLaser():
	global laser
	nearestUfo = ufos[0]
	for ufo in ufos:
		if nearestUfo.d > ufo.d :
			nearestUfo = ufo
	laser = Laser(nearestUfo.cs,nearestUfo.si,nearestUfo.migigawa)

def fireLaser():
	curDeads = []
	for ufo in ufos:
		if hit(laser,ufo):
			curDeads.append(ufo)
	#print str(len(curDeads)) +" ufos burned!"
	for ufo in curDeads:
		ufos.remove(ufo)
		#print ufo
	del curDeads

def oneLogic():
	global gameend
	gameOneMinMove()
	if gameend:
		pass
	else:
		setLaser()
		fireLaser()

def allLogic():
	global gameend
	while not gameend:
		oneLogic()


for inp in stdin:
#for inp in open("input.txt"):
	inp = map(int,inp.split())
	if len(inp) == 2:
		if inp == (0,0): break
		(R,N) = tuple(inp)
		ufos = []
		laser = Laser(0,0,False)
		inrl = 0
		gameend = False
	else:
		ufos.append(Ufo(inp[0],inp[1],inp[2],inp[3]))
		if len(ufos) == N:
			allLogic()
			print inrl

### FIXED CODE ###

from math import sqrt

class Ufo:
	def __init__(self,px,py,d,vd,ui):
		self.pd=sqrt(px**2+py**2)
		self.px=float(px)
		self.py=float(py)
		self.ex=self.px/self.pd
		self.ey=self.py/self.pd
		self.d=float(d)
		self.vd=float(vd)
		self.vx=-self.vd*self.ex
		self.vy=-self.vd*self.ey
		self.i=ui
	def move(self):
		self.pd -= self.vd
		self.px += self.vx
		self.py += self.vy



while True:
	R,ul=tuple(map(int,raw_input().split()))
	if(R==0 and ul==0): break
	us=[]
	for ui in xrange(ul):
		px,py,d,vd = tuple(map(int,raw_input().split()))
		u = Ufo(px,py,d,vd,ui)
		us.append(u)

	re=0
	while True:
		for u in us: u.move()
		us.sort(key=lambda u: u.pd)

		for u in us[:]:
			if u.pd<=R:
				re+=1
				us.remove(u)
				#print u.i, "due to invade"
				continue
			else:
				break
		if len(us)==0: break

		neu=us.pop(0)
		#print "focus",neu.i
		#print neu.i,"due to hit"

		for u in us[:]:
			d = u.pd*abs(neu.ex*u.ey-neu.ey*u.ex)	#u kara laser ni orosita suisen no nagasa
			if d<u.d:
				if u.pd*(neu.ex*u.ex+neu.ey*u.ey)+sqrt(u.d**2-d**2) > R:
					us.remove(u)
					#print u.i, "due to hit"
		if len(us)==0: break

	print re
S = list(input())
T = list(input())
dics ={}
dic ={}
for i in range(len(S)):
  if S[i] in dics:
  	dics[S[i]]=[dics[S[i]],i]
  else :
    dics[S[i]]=i
  if T[i] in dic:
    dic[T[i]]=[dic[T[i]],i]
  else:
    dic[T[i]]=i
for i in range(len(S)):
  if dics[S[i]]!=dic[T[i]] and (T[i] in dics and dics[T[i]]!=dic[S[i]]):
    print("No")
    exit()
print("Yes")

  

### FIXED CODE ###

S=input()
T=input()
convert = {}
flag=1
for s,t in zip(S,T):
  if s in convert and convert[s]!=t:
    flag=0
    break
  convert[s] = t
after = convert.values()
if len(after)!= len(set(after)):
  flag = 0

print("Yes" if flag else "No")
s=input()
print(s[0]+(len(s)-2)+s[len(s)-1])


### FIXED CODE ###

s=input()
print(s[0]+str(len(s)-2)+s[len(s)-1])
from collections import Counter
from scipy.misc import comb

N = int(input())
A = list(map(int, input().split()))
ans = 0
cumulative_sum = [0] + [sum(A[:i+1]) for i in range(N)]
counts = Counter(cumulative_sum)
ans = 0
for v in counts.values():
    ans += v * (v-1) // 2
    
print(ans)


### FIXED CODE ###

from collections import Counter
import numpy as np

N = int(input())
A = [0]+list(map(int, input().split()))

cumulative_sum = np.cumsum(A)
counts = Counter(cumulative_sum)
ans = 0
for v in counts.values():
    ans += v * (v-1) // 2
    
print(ans)
s=input()
a = list(map(int,input().split()))
x=len(a)
f=0
for k in range 1000000000:
    f=f+1
    for i in range x:
        a[i]=0.5*a[i]
        if a[i]%2=1:
            break
    else:
        continue
    break
h=f-1
print("h")



### FIXED CODE ###

s=input()
a = list(map(int,input().split()))
x=len(a)
f=0
for k in range(1000000000):
    f=f+1
    for i in range(x):
        if a[i]%2 == 1:
            break
        a[i]=0.5*a[i]
    else:
        continue
    break
print(f-1)
A = int(input())
b = int(input())
if(A > B):
  print("Alice")
elif(B > A):
  print("Bob")
else:
  print("Draw")

### FIXED CODE ###

A, B = map(int, input().split())
if(A ==1):
  A += 13
if(B ==1):
  B += 13
if(A > B):
  print("Alice")
elif(B > A):
  print("Bob")
else:
  print("Draw")
from math import ceil, log


class SegmentTree(object):
    __slots__ = ["elem_size", "tree", "default", "op"]

    def __init__(self, a: list, default: int, op):
        real_size = len(a)
        self.elem_size = elem_size = 1 << ceil(log(real_size, 2))
        self.tree = tree = [default] * (elem_size * 2)
        tree[elem_size:elem_size + real_size] = a
        self.default = default
        self.op = op

        for i in range(elem_size - 1, 0, -1):
            tree[i] = op(tree[i << 1], tree[(i << 1) + 1])

    def get(self, x: int, y: int) -> int:  # [x, y)
        l, r = x + self.elem_size, y + self.elem_size
        tree, result, op = self.tree, self.default, self.op
        while l < r:
            if l & 1:
                result = op(tree[l], result)
                l += 1
            if r & 1:
                r -= 1
                result = op(tree[r], result)
            l, r = l >> 1, r >> 1

        return result

    def set(self, i: int, value: int) -> None:
        k = self.elem_size + i
        self.tree[k] = value
        self.update(k)

    def update(self, i: int) -> None:
        op, tree = self.op, self.tree
        while i > 1:
            i >>= 1
            tree[i] = op(tree[i << 1], tree[(i << 1) + 1])


N, Q = map(int, input().split())
c = list(map(int, input().split()))

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

lr.sort(key=lambda x: x[1])

rightest = [-1] * N
rightest_pos = set()

current_q = 0

s = SegmentTree([0] * N, 0, lambda x, y: x + y)

ans = [0] * Q

for i in range(N):
    if rightest[c[i]] != -1:
        rightest_pos.remove(rightest[c[i]])
        s.set(rightest[c[i]], 0)
    rightest[c[i]] = i
    rightest_pos.add(i)
    s.set(i, 1)

    while current_q < Q and lr[current_q][1] == i:
        ans[lr[current_q][2]] = s.get(lr[current_q][0], lr[current_q][1] + 1)
        current_q += 1

for i in range(Q):
    print(ans[i])


### FIXED CODE ###

class Bit:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n+1)

    def sum(self, i):  # sum in [0, i)
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):  # i > 0
        assert i > 0
        while i <= self.size:
            self.tree[i] += x
            i += i & -i


N, Q = map(int, input().split())
c = list(map(int, input().split()))

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

lr.sort(key=lambda x: x[1])

rightest = [-1] * (N + 1)
current_q = 0
bit = Bit(N)
ans = [0] * Q

for i in range(N):
    if rightest[c[i]] != -1:
        bit.add(rightest[c[i]]+1, -1)
    rightest[c[i]] = i
    bit.add(i+1, 1)

    while current_q < Q and lr[current_q][1] == i:
        ans[lr[current_q][2]] = bit.sum(lr[current_q][1] + 1) - bit.sum(lr[current_q][0])
        current_q += 1

for i in range(Q):
    print(ans[i])
class Main:

    s = int(input().split());

    if s[0] <= s[1]:
        print("unsafe");
    else:
        print("safe");


### FIXED CODE ###

class Main:

    s1, s2= map(int,input().split());

    if s1 <= s2:
        print("unsafe");
    else:
        print("safe");
x, y, a, b, c = map(int, input().split())

p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))

p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)

eat_list = []

for _ in range(x):
    if p[0] < r[0]:
        eat_list.append(r.pop(0))
    else:
        eat_list.append(p.pop(0))

for _ in range(y):
    if q[0] < r[0]:
        eat_list.append(r.pop(0))
    else:
        eat_list.append(q.pop(0))

print(sum(eat_list))
    

### FIXED CODE ###

x, y, a, b, c = map(int, input().split())

p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))

p.sort(reverse=True)
q.sort(reverse=True)

eat_list = []

for i in range(x):
    eat_list.append(p[i])
for i in range(y):
    eat_list.append(q[i])
for i in range(c):
    eat_list.append(r[i])
    
eat_list.sort(reverse=True)

ans = 0

for i in range(x+y):
    ans += eat_list[i]

print(ans)
from collections import defaultdict
def generate_primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]

def main():  
    n = int(input())
    A = list(map(int, input().split()))
    d = defaultdict(int)
    primes = generate_primes(max(A))
    for a in A:
        for p in primes:
            if a < p: break
            if a % p == 0:
                d[p] += 1
    d[1] = 0
    m = max(d.values())
    if m == n:
        print('not coprime')
    elif m >= 2:
        print('setwise coprime')
    else:
        print('pairwise coprime')
    

if __name__ == '__main__':
    main()



### FIXED CODE ###

import sys
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            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.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

def main():
    input = sys.stdin.readline
    n, m = map(int, input().split())
    uf = UnionFind(n)
    for _ in range(m):
        a, b = map(lambda x: int(x) - 1, input().split())
        uf.union(a, b)
    ans = max(-uf.parents[uf.find(x)] for x in uf.roots())
    print(ans)


if __name__ == '__main__':
    main()
N, A, B, C = map(int, input().split())
l = [int(input()) for _ in range(N)]
INF = 10 ** 9

def dfs(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 = dfs(cur + 1, A, B, C)
  # A に使う場合
  ret1 = dfs(cur + 1, A + l[cur], B, C) + 10
  # B に使う場合
  ret2 = dfs(cur + 1, A, B + l[cur], C) + 10
  # C に使う場合
  ret3 = dfs(cur + 1, A, B, C + l[cur]) + 10
  
  return min(ret0, ret1, ret2, ret3)
  
print(defs(0, 0, 0, 0))

### FIXED CODE ###

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

def dfs(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 = dfs(cur + 1, a, b, c)
  # A に使う場合
  ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
  # B に使う場合
  ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
  # C に使う場合
  ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
  
  return min(ret0, ret1, ret2, ret3)
  
print(dfs(0, 0, 0, 0))
a,b=map(int,input().split())
lista=[]
import fractions
gcd=fractions.gcd(a,b)

for i in range(2,gcd+1):
    if a% i == 0 and b % i == 0: 
        lista.append(i)
        
listb=[]
for i in range(len(lista)):   
    if pow(2, lista[i]-1, lista[i]) == 1:
            listb.append(lista[i])
#print(listb)   

if lista[1]==2:   
print(len(listb)+2)

else:
    print(len(listb)+1)


### FIXED CODE ###

a,b=map(int,input().split())
lista=[]
import fractions
import math
gcd=fractions.gcd(a,b)

for i in range(1,int(gcd**0.5)+1): 
    if gcd% i == 0: 
        lista.append(i)
        if i!=int(gcd/i):
            lista.append(int(gcd/i))

#print(lista)
lista=lista[1:]
lista.sort()
listb=[]
for i in range(len(lista)):
    flag = True
    for j in range(len(listb)):
        if lista[i]%listb[j]==0:
            flag = False    
    if flag==True:
        listb.append(lista[i])

print(len(listb)+1)
a, b, c = map(int, input(),split())

print(int((a*b)/2))

### FIXED CODE ###

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

print((a*b)//2)
for i in range(int(input())):
    xa, ya, xb, yb = map(int, input().split(' '))
    n = int(input())
    ip = []
    for j in range(n):
        xs, ys, xt, yt, o, l = map(int, input().split(' '))
        d = (xb - xa) * (yt - ys) - (yb - ya) * (xt - xs)
        if d == 0:
            continue
        t0 = ((yt - ys) * (xs - xa) - (xt - xs) * (ys - ya)) / d
        t1 = ((yb - ya) * (xs - xa) - (xb - xa) * (ys - ya)) / d
        if (t0 > 0 and t0 < 1) and (t1 > 0 and t1 < 1):
            ip.append((t0, o == l))
    count = 0
    if len(ip) > 0:
        ip.sort(key=lambda x: x[0])
        for j in range(len(ip) - 1):
            if ip[j][1] != ip[j + 1][1]:
                count += 1
    print(count)

### FIXED CODE ###

for i in range(int(input())):
    xa, ya, xb, yb = map(int, input().split())
    n = int(input())
    ip = []
    for j in range(n):
        xs, ys, xt, yt, o, l = map(int, input().split())
        d = (xb - xa) * (yt - ys) - (yb - ya) * (xt - xs)
        if d == 0:
            continue
        t0 = ((yt - ys) * (xs - xa) - (xt - xs) * (ys - ya)) / d
        t1 = ((yb - ya) * (xs - xa) - (xb - xa) * (ys - ya)) / d
        if (t0 > 0 and t0 < 1) and (t1 > 0 and t1 < 1):
            ip.append((t0, o == l))
    count = 0
    if len(ip) > 0:
        ip.sort(key=lambda x: x[0])
        for j in range(len(ip) - 1):
            if ip[j][1] != ip[j + 1][1]:
                count += 1
    print(count)
k = input()
s = input()
if(len(s)<=k):
  print(s)
else:
  print(s[:k])

### FIXED CODE ###

k = input()
s = input()
if(len(s) <= int(k)):
  print(s)
else:
  print(s[:int(k)]+'...')
S,T = .input().split()
print("T+S")

### FIXED CODE ###

S,T =input().split()
print(T+S)
N=int(input())
temp=[input().split() for i in range(N)]
A=[int(temp[i]) for i in range(N)]

A=A[-1]+A

for i in range(N):
  print((A[i]+A[i+1])/2)

### FIXED CODE ###

N=int(input())
temp=input().split()
A=[int(temp[i]) for i in range(N)]
As=[]
As.append(sum([A[i]*pow(-1, i) for i in range(N)]))
for i in range(1, N):
  As.append(A[i-1]-As[i-1])

x1=As[0]/2
print(int(2*x1), end=' ')

for i in range(1, N):
  print(2*int(As[i]-x1*pow(-1, i)), end=' ')
from math import ceil
from bisect import bisect

n, a, b = map(int, input().split())
raw_hs = [int(input()) for _ in range(n)]
hs = sorted(raw_hs, reverse=True)
diff = a - b

c_min = 0
c_max = int(10e9)

while c_max - c_min > 1:
	c = (c_min + c_max) // 2
	tmp_hs = [h - c * b for h in hs]
	rem = sum([ceil(h / diff) for h in tmp_hs if h > 0])
	if rem > c:
		c_min = c
	else:
		c_max = c

print(c_max)


### FIXED CODE ###

res = sum(map(int, input().split()))
if res >= 10:
	print("error")
else:
	print(res)
def main():
    N = int(input())

    ans = 0
    for i in range(len(str(N))):
        if len(str(N)) != i+1:
            if i % 2 == 0:
                ans += 9*(10**i)
        else:
            if i % 2 == 0:
                if int(str(N)[1:]) == 0:
                    ans += 1
                else:
                    ans += int(str(N)[1:])
    print(ans)


if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    N = int(input())

    ans = 0
    if len(str(N)) % 2 == 0:
        for i in range(len(str(N))):
            if i % 2 == 0:
                ans += 9*(10**i)
    else:
        for i in range(len(str(N))+1):
            if i % 2 == 0:
                ans += 9*(10**i)
        ans = ans - (10**len(str(N)) - N) + 1
        
    print(ans)

if __name__ == "__main__":
    main()
def is_prime(n):
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return n != 1:
        

x = int(input())
while not is_prime(x):
    x += 1
print(x)

### FIXED CODE ###

import math
def is_prime(n):
    if n == 2:
        return True
    if (n < 2) or (n % 2 == 0):
        return False
    stop = math.floor(math.sqrt(n)) + 1
    for i in range(3, stop, 2):
        if n % i == 0:
            return False
    return True

x = int(input())
while not is_prime(x):
    x += 1
print(x)
a???,b = input().split(' ')
if int(a) > int(b):
	print(a???> b)
elif int(a) < int(b):
	print(a < b)
else:
	print(a == b)

### FIXED CODE ###

a,b = input().split(' ')
if int(a) > int(b):
	print('a > b')
elif int(a) < int(b):
	print('a < b')
else:
	print('a == b')
N, M, K = map(int,input().split())
tree = [-1 for _ in range(N)]
fc = [0] * N
bc = [0] * N
ans = [0] * N

def find(x):
    # x を引数に取り、xのroot番号を取得するメモ化再帰
    if tree[x] < 0:
        return x
    tree[x] = find(tree[x])
    return tree[x]

def unite(x, y):
    # x, y を引数に取り、x(自分)をy(相手)のrootに接続する関数
    rootx = find(x)
    rooty = find(y)
    if rootx == rooty:
        return
    if rootx < rooty:
        x , y = y, x
    tree[rooty] += tree[rootx]
    tree[rootx] = rooty

for m in range(M):
    a, b = map(int,input().split())
    fc[a-1] += 1
    fc[b-1] += 1
    unite(a-1, b-1)

for k in range(K):
    c, d = map(int,input().split())
    if find(c-1) == find(d-1):
        bc[c-1] += 1
        bc[d-1] += 1

for i in range(N):
    cnt = -tree[find(i)] - 1 - fc[i] - bc[i]
    ans[i] = cnt

print(*ans)

### FIXED CODE ###

N, M, K = map(int,input().split())
uf = [-1 for _ in range(N)]
fc = [0] * N
bc = [0] * N
ans = [0] * N

def find(x):
    # x を引数に取り、xのroot番号を取得するメモ化再帰
    if uf[x] < 0:
        return x
    uf[x] = find(uf[x])
    return uf[x]

def unite(x, y):
    # x, y を引数に取り、x(自分)をy(相手)のrootに接続する関数
    x = find(x)
    y = find(y)
    if x == y:
        return
    if x < y:
        x , y = y, x
    uf[y] += uf[x]
    uf[x] = y

for m in range(M):
    a, b = map(int,input().split())
    fc[a-1] += 1
    fc[b-1] += 1
    unite(a-1, b-1)

for k in range(K):
    c, d = map(int,input().split())
    if find(c-1) == find(d-1):
        bc[c-1] += 1
        bc[d-1] += 1

for i in range(N):
    cnt = -uf[find(i)] - 1 - fc[i] - bc[i]
    ans[i] = cnt

print(*ans)
K = int(input())
a,b = map(int, input().split())
if a < K and K < B:
    print("OK")
elif (b - a)/K >= 1:
    print("OK")
elif (b-a)== 0 and K == 1:
    print("OK")
else :
    print("NG")

### FIXED CODE ###

K = int(input())
a,b = map(int, input().split())
kekka = ("NG")
for i in range(a,b+1):
    if i % K == 0:
        kekka = ("OK")
print(kekka)
import math, fractions


def prime_number(n, include_one=True):
    N = n + 1
    table = [0] * N
    
    if include_one:
        prime_list = [1]
    else:
        prime_list = []
    
    for i in range(2, N):
        if table[i] == 0:
            prime_list.append(i)
            
            for j in range(i + i, N, i):
                table[j] = i
    
    return prime_list

def prime_factor(n, include_one=True):
    prime_list = prime_number(n, include_one)
    
    ret = 0
    for i in prime_list:
        if n % i == 0:
            ret +=1
            n /= i
            
    return ret

if __name__ == "__main__":
    A, B = map(int, input().split())
    n = fractions.gcd(A, B)
    print(prime_factor(n))

### FIXED CODE ###

import math, fractions


def num_prime_factor(n):
    
    ret = 0

    for i in range(1, int(math.sqrt(n)) + 2):

        composite = False

        if n % i == 0:
            ret += 1
            n = n / i

            if i != 1:
                while n % i == 0:
                    n = n / i

            if n == 1:
                break

            for j in range(2, int(math.sqrt(n)) + 2):
                if n % j == 0:
                    composite = True
                    break

            if not composite:
                ret += 1
                break

    return ret

if __name__ == "__main__":
    A, B = map(int, input().split())
    n = fractions.gcd(A, B)
    print(num_prime_factor(n))
while True:
    x, y = sorted(map(int, raw_input().split()))
    if x == y == 0:
        break
    print x,y
    

### FIXED CODE ###

while True:
    x, y = sorted(map(int, raw_input().split()))
    if x == y == 0:
        break
    print x,y
N = int(input())
L = [input().split() for i in range(N)]
answer = 0
center = []

for i in range(101):
  for j in range(101):
    List = []
    for l in L:
      if int(l[2]) != 0:
        List.append(int(l[2]) + abs(int(l[0]) - i) + abs(int(l[1]) - j))
      else:
        List.append(0)
    if len(list(set(List))) == 1:
      answer = List[0]
      center.append(i)
      center.append(j)

print(center[0], center[1], answer)

### FIXED CODE ###

#!/usr/bin/env python3
import sys


def solve(N: int, x: "List[int]", y: "List[int]", h: "List[int]"):
    X = 0
    Y = 0
    hh = 0
    for i in range(0, 101):
        for j in range(0, 101):
            H =  []
            s = 0
            for k in range(N):
                if h[k] > 0:
                    s += h[k]
                    H.append(h[k] + abs(x[k] - i) + abs(y[k] - j))
            if len(H) > 1 and len(list(set(H))) == 1:
                X, Y, hh = i, j, H[-1]
            elif len(H) == 1 and H[0] == s:
                X, Y, hh = i, j, H[0]

    print(X, Y, hh)
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    x = [int()] * (N)  # type: "List[int]" 
    y = [int()] * (N)  # type: "List[int]" 
    h = [int()] * (N)  # type: "List[int]" 
    for i in range(N):
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
        h[i] = int(next(tokens))
    solve(N, x, y, h)

if __name__ == '__main__':
    main()
n = int(input())

ans = ""
cnt = 0

while n != 0:
    new = n - (-2) ** cnt
    if new % (2 ** (cnt + 1)) == 0:
        ans = "1" + ans
        n = n - (-2) ** cnt
    else:
        ans = "0" + ans
    cnt += 1
    aa += 1
print(ans)


### FIXED CODE ###

n = int(input())
base = 2
ans =""

while n != 0:
  ans = str(n%base)+ans
  n = -(n//base)
if ans:
  print(ans)
else:
  print(0)
s = str(input()).split(" "):
if s[0][0] == s[1][-1] and s[1][0] == s[2][-1]:
  print("YES")
else:
  print("NO")

### FIXED CODE ###

s = str(input()).split(" ")
if s[0][-1] == s[1][0] and s[1][-1] == s[2][0]:
  print("YES")
else:
  print("NO")
import sympy

A,B = map(int,input().split())
sympy.var("x")
sol1 = sympy.solve(x*0.08-A,x)
sol2 = sympy.solve(x*0.10-B,x)
ans = lambda x1,x2 : x1 if x1 == x2 else -1
print(int(ans(sol1[0],sol2[0])))

### FIXED CODE ###

import math
A,B = map(int,input().split())
sol1 = math.ceil(A/0.08)
sol2 = math.ceil(B/0.10)
ans = lambda x1,x2 : x1 if x1 == x2 else -1
flagA = True
flagB = True
while True:
    if(sol1 * 0.08 < A and flagA):
        flagA = False
        if(math.floor((sol1+1)*0.10) == B):
            print(sol1+1)
            break
    sol1 -= 1
    if(sol2 * 0.10 < B and flagB):
        flagB = False
        if(math.floor((sol2+1)*0.08) == A):
            print(sol2+1)
            break
    if(not flagA and not flagB):
        print(-1)
        break
    sol2 -= 1