Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
n = int(input())
cards = {} #空の辞書
for i in range(n):
    card = input()
    cards[card] = 1
    
#print(cards)

for c in ['S', 'H', 'C', 'D']:
    for n in range(1,13):
        card = c + ' ' + str(n)
        if not key in cards:
            print(key)


Fixed submission:
n = int(input())
cards = {} #空の辞書
for i in range(n):
    card = input()
    cards[card] = 1
    
#print(cards)

for c in ['S', 'H', 'C', 'D']:
    for n in range(1,14):
        key = c + ' ' + str(n)
        if not key in cards:
            print(key)

Buggy python submission (verdict: Runtime Error):
n = int(input())
cards = {} #空の辞書
for i in range(n):
    card = input()
    cards[card] = 1
    
#print(cards)

for c in ['S', 'H', 'C', 'D']:
    for n in range(1,14):
        card = c + ' ' + str(n)
        if not key in cards:
            print(key)


Fixed submission:
n = int(input())
cards = {} #空の辞書
for i in range(n):
    card = input()
    cards[card] = 1
    
#print(cards)

for c in ['S', 'H', 'C', 'D']:
    for n in range(1,14):
        key = c + ' ' + str(n)
        if not key in cards:
            print(key)
Buggy python submission (verdict: Runtime Error):
a,b=map(int, input().split())
if a < b:
    print("a < b")
elif a == b:
    print("a == b")
else:
    print("a > b")


Fixed submission:
a,b = map(int, input().split())
if a < b:
  print('a < b')
elif a > b:
  print('a > b')
elif a == b:
  print('a == b')
Buggy python submission (verdict: Runtime Error):
a,b,c = map(int, input().split())
　org_list =[a, b, c]
　org_list.sort()
print(org_list)


Fixed submission:
a, b, c = map(int, input().split())
 
if a<b and a<c:
    if b<c :
        print(a, b, c)
    else :
        print(a, c, b)
elif b<a and b<c :
    if a<c :
        print(b, a, c)
    else :
        print(b, c, a)
else :
    if a<b :
        print(c, a, b)
    else :
        print(c, b, a)

Buggy python submission (verdict: Runtime Error):
a,b,c = map(int, input().split())
org_list =[a, b, c]　
org_list.sort()
print(org_list)


Fixed submission:
a, b, c = map(int, input().split())
 
if a<b and a<c:
    if b<c :
        print(a, b, c)
    else :
        print(a, c, b)
elif b<a and b<c :
    if a<c :
        print(b, a, c)
    else :
        print(b, c, a)
else :
    if a<b :
        print(c, a, b)
    else :
        print(c, b, a)
Buggy python submission (verdict: Runtime Error):
while True:
    x,y = map(int, input().split())
    if x == 0 and y == 0:
    break
if x > y:
    print(y, x)
else:
    print(x, y)


Fixed submission:
c = 1  
while True:
    x = int(input())
    if x == 0: 
       break
    print("Case {}: {}".format(c, x))
    c += 1
Buggy python submission (verdict: Runtime Error):
while True:
    x,y = map(int, input().split())
    if x == 0 and y == 0:
    break
if x > y:
    print(y, x)
else:
    print(x, y)


Fixed submission:
while True:
    x,y = map(int, input().split())
    if x == 0 and y == 0:break
    if x > y:
       print(y, x)
    else:
       print(x, y)
Buggy python submission (verdict: Runtime Error):
while True:
  H,W = map(int,input().split())
    if H == 0 and W == 0:
        break
    for i in range(H):
        for k in range(W):
            if (i+k)%2 == 0:
                print("#",end = "")
            else:
                print(".",end = "")
        print()


Fixed submission:
while 1:
    (H,W) = [int(i) for i in input().split()]
    if H==W==0:
        break
    for i in range(H):
        for j in range(W):
            if (i+j)%2==0: print('#',end="")
            else: print('.',end="")
        print('')
    print('')
Buggy python submission (verdict: Runtime Error):
i,j=map(int,input().split())
listA=[]
for i in range(i):
    listA.append(list(map(int,input().split())))
    listA[n].append(sum(listA[n]))
listA.append([])
for n in range(j+1):
    number =0
    for m in range(i):
        number+=listA[m][n]
    listA[i].append(number)
for n in range(i+1):
    print(''.join(map(str,listA[n])))
   


Fixed submission:
i,j=map(int,input().split())
listA=[]
for n in range(i):
    listA.append(list(map(int,input().split())))
    listA[n].append(sum(listA[n]))
listA.append([])
for n in range(j+1):
    number=0
    for m in range(i):
        number+=listA[m][n]
    listA[i].append(number)
for n in range(i+1):
    print(' '.join(map(str,listA[n])))
Buggy python submission (verdict: Runtime Error):
s = input()
S = int(s)
a = S/(60*60)
b = (S-(int(a))*60*60)/60
c = S-(int(a)*60*60 + int(b)*60)
print(int(a), ":", int(b), ":", int(c)\n)


Fixed submission:
S = int(input())
a = S//(60*60)
b = (S-(a*60*60))//60
c = S-(a*60*60 + b*60)
print(a, ':', b, ':', c, sep='')
Buggy python submission (verdict: Runtime Error):
x=int(input())
print(x/3600, ':', (x-x/3600)/60, ':', x-{(x-x/3600)/60}, sep='')



Fixed submission:
a, b=map(int, input().split())
print(a*b, a+a+b+b)

Buggy python submission (verdict: Runtime Error):
x=int(input())

print(x//3600, ':', (x-x//3600)//60, ':', x-{(x-x//3600)//60}, sep='')



Fixed submission:
a, b=map(int, input().split())
print(a*b, a+a+b+b)
Buggy python submission (verdict: Runtime Error):
x=int(input())
print(x/3600, ':', (x-x/3600)/60, ':', x-{(x-x/3600)/60}, sep='')



Fixed submission:
x=int(input())
a=x//3600
b=(x-a*3600)//60
c=x-(a*3600+b*60)
print(a, ':', b, ':', c, sep='')

Buggy python submission (verdict: Runtime Error):
x=int(input())
a=x//3600
b=(x-x//3600)//60
c=x-{(x-x//3600)//60}
print(a, ':', b, ':', c, sep='')


Fixed submission:
x=int(input())
a=x//3600
b=(x-a*3600)//60
c=x-(a*3600+b*60)
print(a, ':', b, ':', c, sep='')
Buggy python submission (verdict: Runtime Error):
W, H, x, y, r=map(int, input().split())
if x>= r and x+r<=W and y>=r and y+r<=
print("Yes")
else:
print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <=
print("Yes")
else:
print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H
print("Yes")
else:
print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
print("Yes")
else:
print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H
print("Yes")
else:
print("No")# co


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H
print("Yes")
else:
print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H
 print("Yes")
else:
 print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H
  print("Yes")
else:
  print("No")


Fixed submission:
W, H, x, y, r = map(int, input().split())
if x >= r and x + r <= W and y >= r and y + r <= H:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
a,b = map(input().split())
print(a//b)
print(a%b)
print(a/b)


Fixed submission:
a,b = [int(x) for x in input().split()]
print(a//b, a%b, "{:f}".format(a/b))
Buggy python submission (verdict: Runtime Error):
from math import pi
r = int(input())
print(pi*r**2, 2*pi*r)


Fixed submission:
from math import pi
r = float(input())
print("{0} {1}".format(r * r * pi, (r + r) * pi))

Buggy python submission (verdict: Runtime Error):
import math
pi = math.pi
r = int(input())
print(pi*r**2, 2*pi*r)


Fixed submission:
from math import pi
r = float(input())
print("{0} {1}".format(r * r * pi, (r + r) * pi))

Buggy python submission (verdict: Runtime Error):
import math
pi = math.pi
r = int(input())
print(pi*r*r, 2*pi*r)


Fixed submission:
from math import pi
r = float(input())
print("{0} {1}".format(r * r * pi, (r + r) * pi))

Buggy python submission (verdict: Runtime Error):
import math
r = int(input())
print(math.pi * r * r, 2 * math.pi * r)


Fixed submission:
from math import pi
r = float(input())
print("{0} {1}".format(r * r * pi, (r + r) * pi))
Buggy python submission (verdict: Runtime Error):
from collections import deque

a = [int(i) for i in input().split()]
q = deque([])
for i in range(a[0]): q.append(deque([]))

for i in range(a[1]):
    cmd = [int(i) for i in input().split()]

    if cmd[0] == 0:
        q[cmd[1]].append(cmd[2])

    elif cmd[0] == 1:
        if q[cmd[1]] != []: print(q[cmd[1]][0])

    elif cmd[0] == 2:
        if q[cmd[1]] != []: q[cmd[1]].popleft()



Fixed submission:
from collections import deque

a = [int(i) for i in input().split()]
q = deque([])
for i in range(a[0]): q.append(deque([]))

for i in range(a[1]):
    cmd = [int(i) for i in input().split()]

    if cmd[0] == 0:
        q[cmd[1]].append(cmd[2])

    elif cmd[0] == 1:
        if q[cmd[1]] != deque([]): print(q[cmd[1]][0])

    elif cmd[0] == 2:
        if q[cmd[1]] != deque([]): q[cmd[1]].popleft()
Buggy python submission (verdict: Runtime Error):
a,b = map(int,input().split())

if a > b:
op = '>'
elif a < b:
op = '=='

print("a %s b"%op)



Fixed submission:
a,b = map(int, input().split())
if a<b:
	print("a < b")
elif a==b:
	print("a == b")
else:
	print("a > b")

Buggy python submission (verdict: Runtime Error):
a,b = map(int,input().split())

if a > b:
op = '>'
elif a < b:
op = '<'
else:
op = '=='

print("a %s b"%op)



Fixed submission:
a,b = map(int, input().split())
if a<b:
	print("a < b")
elif a==b:
	print("a == b")
else:
	print("a > b")

Buggy python submission (verdict: Runtime Error):
a,b = map(int,input().split())

if a > b:
op = '>'
elif a < b:
op = '<'
else:
op = '=='

print("a %s b"%op)



Fixed submission:
a,b = map(int, input().split())
if a<b:
	print("a < b")
elif a==b:
	print("a == b")
else:
	print("a > b")

Buggy python submission (verdict: Runtime Error):
a,b = map(int , input().split())
if a < b :
print("a < b")
elif a > b:
print("a > b")
else:
print("a == b")



Fixed submission:
a,b = map(int, input().split())
if a<b:
	print("a < b")
elif a==b:
	print("a == b")
else:
	print("a > b")

Buggy python submission (verdict: Runtime Error):
a,b = map(int , input().split())
if a < b :
print("a < b")
elif a > b:
print("a > b")
else:
print("a == b")



Fixed submission:
a,b = map(int, input().split())
if a<b:
	print("a < b")
elif a==b:
	print("a == b")
else:
	print("a > b")

Buggy python submission (verdict: Runtime Error):
a, b = map(int, input().split())

if a < b :
  print('a < b')
elif a > b :
  print('a > b')
else:
  print('a == b'


Fixed submission:
a,b=map(int,input().split())
if a < b :
  print('a < b')
elif a > b :
  print('a > b')
else :
  print('a == b')

Buggy python submission (verdict: Runtime Error):
a, b = map(int, input().split())

if a < b :
  print('a < b')
else a > b :
  print('a > b')
else:
  print('a == b')


Fixed submission:
a,b=map(int,input().split())
if a < b :
  print('a < b')
elif a > b :
  print('a > b')
else :
  print('a == b')
Buggy python submission (verdict: Time Limit Exceeded):
import sys
from heapq import heappush, heapify

def solve():
    file_input = sys.stdin
    N, R, L = map(int, file_input.readline().split())
    
    hq = []
    m = {}
    for i in range(1, N + 1):
        team = [0, i, 0]
        heappush(hq, team)
        m[i] = team
    
    time = 0
    for line in file_input:
        d, t, x = map(int, line.split())
        m[d][0] -= x
        hq[0][2] += t - time
        time = t
        heapify(hq)
    hq[0][2] += L - time
    ans_team = max(hq, key = lambda x: (x[2], -x[1]))
    print(ans_team[1])

solve()


Fixed submission:
import sys
from heapq import heappush, heappop, heapreplace
 
def solve():
    file_input = sys.stdin
    N, R, L = map(int, file_input.readline().split())
     
    pq = [[0, i] for i in range(1, N + 1)]
    m = dict(zip(range(1, N + 1), pq))
    time = [0] * (N + 1)
    INVALID = -1
     
    pre_t = 0
    for line in file_input:
        d, t, x = map(int, line.split())
        top_team = pq[0]
        time[top_team[1]] += t - pre_t
        pre_t = t
         
        if top_team[1] == d:
            top_team[0] -= x
            if x < 0:
                heapreplace(pq, top_team)
        else:
            scored_team = m[d][:]
            scored_team[0] -= x
            heappush(pq, scored_team)
            m[d][1] = INVALID
            m[d] = scored_team
         
        while pq[0][1] == INVALID:
            heappop(pq)
    time[pq[0][1]] += L - pre_t
    print(time.index(max(time)))
 
solve()
Buggy python submission (verdict: Runtime Error):
def solve():
    def dfs(start):
        unvisited = [True] * (n + 1)
        queue = [(start, 1)]
        max_chain_len = 1
        while queue:
            ring, chain_len = queue.pop()
            if unvisited[ring]:
                unvisited[ring] = False
                max_chain_len = max(max_chain_len, chain_len)
                for r in adj_list[ring]:
                    if unvisited[r]:
                        queue.append((r, chain_len + 1))
        return max_chain_len
    
    import sys
    file_input = sys.stdin
    
    while True:
        n = int(file_input.readline())
        if n == 0:
            break
        
        adj_list = [[] for _ in range(n + 1)]
        for _ in range(n):
            a, b = map(int, file_input.readline().split())
            adj_list[a].append(b)
            adj_list[b].append(a)
        
        max_len = 0
        for s in range(1, n + 1):
            max_len = max(max_len, dfs(s))
        
        print(max_len)

solve()


Fixed submission:
def solve():
    def dfs(ring, chain_len=1):
        unchecked[ring] = False
        unvisited[ring] = False
        len_rec[ring] = max(len_rec[ring], chain_len)
        for r in adj_list[ring]:
            if unvisited[r]:
                dfs(r, chain_len + 1)
        unvisited[ring] = True
    
    import sys
    file_input = sys.stdin
    
    while True:
        n = int(file_input.readline())
        if n == 0:
            break
        
        rings = []
        adj_list = [[] for _ in range(101)]
        for _ in range(n):
            a, b = map(int, file_input.readline().split())
            adj_list[a].append(b)
            adj_list[b].append(a)
            rings.extend([a, b])
        rings = set(rings)
        
        len_rec = [1] * 101
        unchecked = [True] * 101
        unvisited = [True] * 101
        
        for r in rings:
            if unchecked[r]:
                dfs(r)
        dfs(len_rec.index(max(len_rec)))
        
        print(max(len_rec))

solve()
Buggy python submission (verdict: Runtime Error):
import sys

file_input = sys.stdin

n = int(file_input.readline())
m = int(file_input.readline())

adj_list = [[] for i in range(n + 1)]

for line in file_input:
    i, j = map(int, line.split())
    adj_list[i].append(j)

unvisited = [True] * (n + 1)

ans = []

def dfs(u):
    unvisited[u] = False
    for v in adj_list[u]:
        if unvisited[v]:
            dfs(v)
    ans.append(u)

for s in range(1, n + 1):
    if unvisited[s]:
        dfs(s)

ans.reverse()

print(*ans, sep = '\n')

# Check whether there is a Hamilton path
for s, t in zip(ans, ans[1:]):
    if t not in adj_list[s]:
        print(1)
        break
else:
    print(0)


Fixed submission:
import sys

file_input = sys.stdin

n = int(file_input.readline())
m = int(file_input.readline())

adj_list = [[] for i in range(n + 1)]

indeg = [0] * (n + 1)

for line in file_input:
    i, j = map(int, line.split())
    adj_list[i].append(j)
    indeg[j] += 1

unvisited = [True] * (n + 1)

from collections import deque
q = deque()

ans = []

def bfs(s):
    q.append(s)
    unvisited[s] = False
    while q:
        u = q.popleft()
        ans.append(u)
        for v in adj_list[u]:
            indeg[v] -= 1
            if indeg[v] == 0 and unvisited[v]:
                unvisited[v] = False
                q.append(v)

# Topological Sort
for s in range(1, n + 1):
    if indeg[s] == 0 and unvisited[s]:
        bfs(s)

print(*ans, sep = '\n')

# Check whether there is a Hamilton path
for s, t in zip(ans, ans[1:]):
    if t not in adj_list[s]:
        print(1)
        break
else:
    print(0)
Buggy python submission (verdict: Time Limit Exceeded):
def solve():
    max_fare = 99000001
    def dijkstra(start, goal):
        unvisited = [i for i in range(n)]
        fare = [max_fare] * n
        fare[start] = 0
        
        while True:
            min_fare = max_fare
            for i in unvisited:
                f = fare[i]
                if f < min_fare:
                    min_fare = f
                    u = i
                    
            if u == goal:
                return min_fare
            elif min_fare == max_fare:
                return -1
            
            unvisited.remove(u)
            
            for v, f in enumerate(adj_matrix[u]):
                if v in unvisited:
                    fare[v] = min(min_fare + f, fare[v])
        
    import sys
    file_input = sys.stdin

    while True:
        n, k = map(int, file_input.readline().split())
        if n == 0 and k == 0:
            break
        
        adj_matrix = [[max_fare] * n for i in range(n)]
        
        for i in range(k):
            line = file_input.readline()
            if line[0] == '0':
                a, b = map(int, line[2:].split())
                print(dijkstra(a - 1, b - 1))
            else:
                c, d, e = map(int, line[2:].split())
                f = min(adj_matrix[c - 1][d - 1], e)
                adj_matrix[c - 1][d - 1] = f
                adj_matrix[d - 1][c - 1] = f

solve()


Fixed submission:
def solve():
    from heapq import heappush, heappop
    def dijkstra(start, goal):
        fare = [99000001] * n
        fare[start] = 0
        pq = [(0, start)]
        
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == goal:
                return u_fare
            
            for f, v in adj[u]:
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        return -1
        
    import sys
    file_input = sys.stdin
    
    while True:
        n, k = map(int, file_input.readline().split())
        if n == 0 and k == 0:
            break
        
        adj = [[] for i in range(n)]
        
        for i in range(k):
            line = file_input.readline()
            if line[0] == '0':
                a, b = map(int, line[2:].split())
                print(dijkstra(a - 1, b - 1))
            else:
                c, d, e = map(int, line[2:].split())
                adj[c - 1].append((e, d - 1))
                adj[d - 1].append((e, c - 1))

solve()
Buggy python submission (verdict: Time Limit Exceeded):
import sys

file_input = sys.stdin

NM = file_input.readline()

import itertools

while NM != '0 0\n':
    N, M = map(int, NM.split())
    P = [int(file_input.readline()) for i in range(N)]
    P.append(0)
    P = list(set(P))
    P.sort()
    scores = map(sum, itertools.combinations_with_replacement(P, 4))
    print(max(filter(lambda x: x <= M, scores)))
    NM = file_input.readline()

Fixed submission:
import sys

file_input = sys.stdin

NM = file_input.readline()

import itertools, bisect

while NM != '0 0\n':
    N, M = map(int, NM.split())
    P = [int(file_input.readline()) for i in range(N)]
    P.append(0)
    scores = map(sum, itertools.combinations_with_replacement(P, 2))
    scores = filter(lambda x: x <= M, scores)
    scores = list(set(scores))
    scores.sort()
    print(max(s + scores[bisect.bisect_right(scores, M - s) - 1] for s in scores))
    NM = file_input.readline()
Buggy python submission (verdict: Runtime Error):
def solve():
    import sys
    from itertools import combinations
    input_lines = sys.stdin.readlines()
    while True:
        N = int(input_lines[0])
        if N == 0:
            break
        distance = []
        for t1, t2 in combinations(input_lines[1:N+1], 2):
            r1, x1, y1 = map(float, t1.split())
            r2, x2, y2 = map(float, t2.split())
            d = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5 -r1 - r2
            distance.append(d)
        print(min(distance))
        del input_lines[:N+1]

solve()


Fixed submission:
def _get_distance(c1, c2):
    return ((c1[1] - c2[1]) ** 2 + (c1[2] - c2[2]) ** 2) ** 0.5 - c1[0] - c2[0]

from itertools import combinations

def _get_min_distance(circles):
    min_d = float("inf")
    for c1, c2 in combinations(circles, 2):
        min_d = min(min_d, _get_distance(c1, c2))
    return min_d

def closest_pair_distance(circles, axis =1):
    # axis: x; 1, y; 2
    n = len(circles)
    if n <= 3:
        return _get_min_distance(circles)
    else:
        mid = n // 2
        r, x, y = zip(*circles)
        
        if len(set(x)) > len(set(y)):
            if axis == 2:
                circles.sort(key = lambda c: c[1] - c[0])
            axis1 = 1
            axis2 = 2
        else:
            if axis == 1:
                circles.sort(key = lambda c: c[2] - c[0])
            axis1 = 2
            axis2 = 1
        
        A_circles = circles[:mid]
        B_circles = circles[mid:]
        
        d_Amin = closest_pair_distance(A_circles.copy(), axis1)
        d_Bmin = closest_pair_distance(B_circles.copy(), axis1)
        dist = min(d_Amin, d_Bmin)
        min_d = dist
        
        A_circles.sort(key = lambda c: c[axis] + c[0])
        B_edge = B_circles[0][axis1] - B_circles[0][0]
        for ac in A_circles[::-1]:
            ac_r = ac[0]
            ac_edge = ac[axis1] + ac_r
            if B_edge - ac_edge >= dist:
                break
            for bc in B_circles:
                bc_r = bc[0]
                if bc[axis1] - bc_r - ac_edge >= dist:
                    break
                if abs(ac[axis2] - bc[axis2]) - ac_r - bc_r < dist:
                    min_d = min(min_d, _get_distance(ac, bc))
        return min_d

# solve
def solve():
    import sys
    input_lines = sys.stdin.readlines()
    while True:
        N = int(input_lines[0])
        if N == 0:
            break
        circles = [tuple(map(float, l.split())) for l in input_lines[1:N+1]]
        print('{:.8f}'.format(closest_pair_distance(circles)))
        del input_lines[:N+1]

solve()