qyliang/CodeNanoFix huggingface dataset:
Buggy code:
X=input()
if X >=30:
    print("Yes")
else:
    print("No")

Fixed code:
X=int(input())

if X>=30:
    print('Yes')
else:
    print('No')
Buggy code:
x = int(input())
ans = "No"

if x > 30:
  ans = "Yes"
  
print(ans)

Fixed code:
x = int(input())
ans = "No"

if x >= 30:
  ans = "Yes"
  
print(ans)
Buggy code:
i=int(input())
if i> 30:
    print("Yes")
else :
    print("No")

Fixed code:
if(int(input()) >= 30):
    print('Yes')
else:
    print('No')
Buggy code:
n = input()
if n >= 30:
  print("Yes")
else:
  print("No")

Fixed code:
n = int(input())
if n>= 30:
  print('Yes')
else:
  print('No')
Buggy code:
x = input()
if(x >= 30):
  print('Yes')
  else:
        print('No')

Fixed code:
x = int(input())
if x >= 30:
  print ('Yes')
else:
  print ('No')
Buggy code:
x=int(input())
if x>=30:
  print("Yes")
  else:
    print("No")

Fixed code:
if int(input()) >= 30:
  print('Yes')
else:
  print('No')
Buggy code:
X=int(input())
if x>=30:
  print("Yes")
else:
  print("No")

Fixed code:
x=int(input())
if x>=30:
  print("Yes")
else:
  print("No")
Buggy code:
temp = int(input())
if temp>=30:
  print("Yes")
else:
  print("No)    

Fixed code:
temp= int(input())

if temp >= 30:
    print('Yes')
else:
    print('No')
Buggy code:
int t = 30
if (t >= 30):
  print('Yes')
else:
  print('No')

Fixed code:
t = int(input())
if (t >= 30):
  print('Yes')
else:
  print('No')
Buggy code:
import sys
input = lambda: sys.stdin.readline().rstrip()

def main():
    x = int(input())
    print('Yse' if x >= 30 else 'No')

if __name__ == '__main__':
    main()


Fixed code:
import sys
input = lambda: sys.stdin.readline().rstrip()

def main():
    x = int(input())
    print('Yes' if x >= 30 else 'No')

if __name__ == '__main__':
    main()
Buggy code:
a=int(input())
a>=30:
  print('Yes')
 else:
  print('No')

Fixed code:
a=int(input())
if a>=30:
  print('Yes')
else:
  print('No')
Buggy code:
n = int(input())
if n <= 30:
  	print("Yes")
else:
  	print("No")

Fixed code:
n=int(input())
if 30<=n :
  print('Yes')
else:
  print('No')
Buggy code:
x=int(input(()))
print(["No","Yes"][x>=30])

Fixed code:
x = int(input())
print(["No", "Yes"][x >= 30])
Buggy code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
x = ni()
if x>=30:
    f=True
else:
    f=False
print(yn(f))


Fixed code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
x = ni()
if x>=30:
    f=True
else:
    f=False
yn(f)
Buggy code:
x = int(input())
b = x - 30
if b => 0:
  print('Yes')
else:
  print("No")

Fixed code:
x = int(input())
b = x - 30
if b >= 0:
  print('Yes')
else:
  print("No")
Buggy code:
x=int(input())
if(x>=30):
  print("Yes")
else:
  prinit("No")

Fixed code:
x=int(input())
if x >=30:
	print("Yes")
else:
	print("No")
Buggy code:
if int(input())>29:
  print(Yes)
else:
  print(No)

Fixed code:
if int(input())>29:
  print("Yes")
else:
  print("No")
Buggy code:
ret = "Yes" if int(input()) >= 30 else "No"

Fixed code:
ret = "Yes" if int(input()) >= 30 else "No"
print(ret)
Buggy code:
t = int(input())
print("Yes" if 30 <= t "No")


Fixed code:
t = int(input())
print("Yes" if 30 <= t else "No")
Buggy code:
x = int(input)
if x<30:
  print('Yes')
 else:
  print('No')

Fixed code:
x = int(input())
if x<30:
  print('No')
else:
  print('Yes')
Buggy code:
if int(input())<30: print('No')
  else: print('Yes')

Fixed code:
if int(input())<30: print('No')
else: print('Yes')
Buggy code:
if int(input()) >=30:
  print("Yes")
if else:
  print("No")

Fixed code:
print("Yes") if int(input()) >= 30 else print("No")
Buggy code:
n = int(input())
if n >= 30:
  print('Yes')
 else:
  print('No')

Fixed code:
n = int(input())
if n >= 30:
    print("Yes")
else:
    print("No")
Buggy code:
X=int(input('X='))
if X>=30:
    print('Yes')
else:
    print('No')
    

Fixed code:
X = int(input())

if X >= 30:
  print("Yes")
else:
  print("No")
Buggy code:
a = int(input())
if (a >= 30):  
    print("Yes")
else
	print("No")

Fixed code:
a = int(input())

if a >= 30:
    print("Yes")
else:
    print("No")
Buggy code:
val = input()

if val>=30:
    print('Yes')
else:
    print('No')

Fixed code:
val = int(input())
if val>=30:
    print('Yes')
else:
    print('No')
Buggy code:
from math import *
from collections import *
from random import *
from bisect import *
import sys
input=sys.stdin.readline
def lis():
    return list(map(int,input().split()))
def ma():
    return map(int,input().split())
def inp():
    return int(input())
x=inp()
s='No'
if(s>=30):
    s='Yes'
print(s)
            

        
            
        
    
        
    


Fixed code:
from math import *
from collections import *
from random import *
from bisect import *
import sys
input=sys.stdin.readline
def lis():
    return list(map(int,input().split()))
def ma():
    return map(int,input().split())
def inp():
    return int(input())
x=inp()
s='No'
if(x>=30):
    s='Yes'
print(s)
Buggy code:
x = int(input())
if x > 30:
    print('Yes')
else:
    print('No')

Fixed code:
x = int(input())
if x >= 30:
    ans = "Yes"
else:
    ans = "No"
print(ans)
Buggy code:
t=input()
t=int(t)
if(t>30):
  print("Yes")
else:
  print("No")

Fixed code:
t=input()
t=int(t)
if(t>=30):
  print("Yes")
else:
  print("No")
Buggy code:
x = int(input())
if x < 30:
  print("No")
 else:
  print("Yes")

Fixed code:
x = int(input())
if(x<30):
  print('No')
else:
  print('Yes')
Buggy code:
X = int(input())
if 30 <= x:
  print("Yes")
else:
  print("No")

Fixed code:
X = int(input())

if 30<=X:
  print("Yes")
else:
  print("No")
Buggy code:
X = int(input())
if X >= 30:
  print(Yes)
else:
  print(No)

Fixed code:
X = int(input())
if X >= 30 :
  print("Yes")
else:
  print("No")
Buggy code:
x = input()
if x>= 30:
    print("Yes")
else:
    print("No")

Fixed code:
x=input()
x=int(x)
if x>=30:
    print('Yes')
else:
    print("No")
Buggy code:
a = int(input())
if a => 30:
  print('Yes')
else:
  print('No')

Fixed code:
a = int(input())
if a >= 30:
    print("Yes")
else :
    print("No")
Buggy code:
x=input()
if x>=30:
  print("Yes")
else:
  print("No")

Fixed code:
x = float(input())

if (x >= 30):
    print('Yes')
else:
    print('No')
Buggy code:
t=int(input())
if(t>30):
	print("Yes")
else:
	print("No")

Fixed code:
t=int(input())
if(t>=30):
	print("Yes")
else:
	print("No")
Buggy code:
def ProblemA(X):
    if X>=30:
        print('Yes')
    else;
        print('No')
X=int(input())
ProblemA(X)

Fixed code:
def ProblemA(X):
    if X>=30:
        print('Yes')
    else:
        print('No')
X=int(input())
ProblemA(X)
Buggy code:
x = input()

if x >= 30 :
  print('Yes')
else :
  print('No')

Fixed code:
x=int(input())
if x>=30: print("Yes")
else: print("No")
Buggy code:
import math
a, b = map(int, input().split())
count = 0
for n in range(a):
    c, d = map(int, input().split())
    e = (c*c) + (d * d)
    if int(math.sqrt(e)) < b:
        count += 1
print(count)

Fixed code:
import math
a, b = map(int, input().split())
count = 0
for n in range(a):
    c, d = map(int, input().split())
    e = pow(c, 2) + pow(d, 2)
    if math.sqrt(e) <=  b:
        count += 1
print(count)
Buggy code:
import math

def main():
    N, D = list(map(int, input().split()))
    ans = 0
    for i in range(0,N):
        A, B = list(map(int, input().split()))
        print(dist)
        if dist <= D:
            ans +=1
    print(ans)


if __name__ == '__main__':
    main()

Fixed code:
import math

def main():
    N, D = list(map(int, input().split()))
    ans = 0
    for i in range(0,N):
        A, B = list(map(int, input().split()))
        dist = math.sqrt(A**2 + B**2)
        if dist <= D:
            ans +=1
    print(ans)


if __name__ == '__main__':
    main()
Buggy code:
import math

n = input().split() 

N = int(n[0])
D = int(n[1])
mainList = [input() for i in range(N)]
print(mainList)
C = 0
for xY in mainList:
    x = int((xY.split())[0])
    y = int((xY.split())[1])
    R = int(x ** 2) + int(y ** 2)
    r = math.sqrt(R)

    if D >= r:
        C += 1

print(C)

Fixed code:
import math

n = input().split() 

N = int(n[0])
D = int(n[1])
mainList = [input() for i in range(N)]

C = 0
for xY in mainList:
    x = int((xY.split())[0])
    y = int((xY.split())[1])
    R = (x ** 2) + (y ** 2)
    r = math.sqrt(R)

    if D >= r:
        C += 1

print(C)
Buggy code:
N,D = map(int,input().split())
l = []
for i in range (N):
    x,y = map(int,input().split())
    l.append(x*x+y*y)
    
ans = 0
for i in range(N):
    if l[i] < D*D:
        cnt += 1

print(cnt)

Fixed code:
N,D = map(int,input().split())
l = []
for i in range (N):
    x,y = map(int,input().split())
    l.append(x*x+y*y)
    
ans = 0
for i in range(N):
    if l[i] <= D*D:
        ans += 1

print(ans)
Buggy code:
n,d = map(int,input().split())
l=list()
for _ in range(n):
  x,y=map(int,input().split())
  l.append([x,y])
count = 0
for x,y in l:
  if int((x**2+y**2)**0.5)<=d:
    count+=1
print(count)

Fixed code:
n,d = map(int,input().split())
l=[]
for _ in range(n):
  x,y=map(int,input().split())
  l.append((x,y))
count = 0
for x,y in l:
  if ((x**2+y**2)**0.5)<=d:
    count+=1
print(count)
Buggy code:
N, D = map(int, input().split())
ans = 0
for i in range(N):
        X, Y = map(int, input().split())
        if X*X+Y*Y<=D:
             ans += 1
print(ans)

Fixed code:
N, D = map(int, input().split())
ans = 0
for i in range(N):
  X, Y = map(int, input().split())
  if X*X+Y*Y<=D*D:
    ans += 1
print(ans)
Buggy code:
a,b=input().split()
a=int(a)
b=int(b)
c=[input().split() for i in range(a)]
d=0
for i in range(a):
  if int(c[i][0])*int(c[i][1])<=b**2:
    d=d+1
print(d)

Fixed code:
a,b=input().split()
a=int(a)
b=int(b)
c=[input().split() for i in range(a)]
d=0
for i in range(a):
  if abs((int(c[i][0]))**2+(int(c[i][1])**2))<=b**2:
    d=d+1
print(d)
Buggy code:
N, D = map(int, input().split())
points = [list(map(int, input().split())) for _ in range(N)]
count = 0
for x, y in points:
  if x**2 + y**2 <= D:
    count += 1
print(count)

Fixed code:
N, D = map(int, input().split())
points = [list(map(int, input().split())) for _ in range(N)]
count = 0
for x, y in points:
  if x**2 + y**2 <= D**2:
    count += 1
print(count)
Buggy code:
import math
n, d = map(int, input().split())
xy = [list(map(int, input().split())) for _ in range(n)]
print(xy)
count = 0

for i in range(n):
    count = count + 1 if math.sqrt(xy[i][0]**2 + xy[i][1]**2) <= d else count

print(count)

Fixed code:
import math
n, d = map(int, input().split())
xy = [list(map(int, input().split())) for _ in range(n)]
count = 0

for i in range(n):
    count = count + 1 if math.sqrt(xy[i][0]**2 + xy[i][1]**2) <= d else count

print(count)
Buggy code:
n, d = map(int, input().split())
cnt = 0
for i in range(n):
    x, y = map(int, input().split())
    if x*x + y*y == d*d:
        cnt += 1

print(cnt)

Fixed code:
n, d = map(int, input().split())
cnt = 0
for i in range(n):
    x, y = map(int, input().split())
    if x*x + y*y <= d*d:
        cnt += 1

print(cnt)
Buggy code:
n,d = map(int,input().split())
ans = 0
for i in range(n):
    x, y = map(int,input().split())
    if (x**2+y**2)**0.05 <= d:
        ans += 1
print(ans)

Fixed code:
n,d = map(int,input().split())
ans = 0
for i in range(n):
    x, y = map(int,input().split())
    if (x**2+y**2)**0.5 <= d:
        ans += 1
print(ans)
Buggy code:
n, d = map(int,input().split())
s == 0
for i in range(n):
	x, y = map(int,input().split())
	if x**2 + y**2 <= d**2:
		s = s + 1
		else:
			s = s
print(s)

Fixed code:
n, d = map(int, input().split())
s = 0
for i in range(n):
	x, y = map(int, input().split())
	if x**2+y**2 <= d**2:
		s += 1
print(s)
Buggy code:
n, d=map(int, input().split())
cnt=0

for i in range(n):
    x, y=map(int, input().split())
    tmp=x**2 + y**2
    if tmp<=d**2z:
        cnt+=1

print(cnt)

Fixed code:
n, d=map(int, input().split())
cnt=0

for i in range(n):
    x, y=map(int, input().split())
    tmp=(x**2 +y**2)**0.5
    if tmp<=d:
        cnt+=1

print(cnt)
Buggy code:
n, d = map(int, input().split())
x = [list(map(int,input().split())) for i in range(n)]

ans = 0
for i,j in x:
    if (i**2)+(j**2)) <= d**2:
        ans += 1

print(ans)

Fixed code:
n, d = map(int, input().split())
x = [list(map(int,input().split())) for i in range(n)]

ans = 0
for i,j in x:
    if (i**2)+(j**2) <= d**2:
        ans += 1

print(ans)
Buggy code:
import math

n, d = map(int, input().split())
cnt = 0
for i in range(n):
  x, y = map(int, input().split())
  dist = math.sqrt(x**2 + y**2)
  if dist <= D:
    cnt += 1

    
print(cnt)

Fixed code:
import math

n, d = map(int, input().split())
cnt = 0
for i in range(n):
  x, y = map(int, input().split())
  dist = math.sqrt(x**2 + y**2)
  if dist <= d:
    cnt += 1

    
print(cnt)
Buggy code:
n,d=map(int,input().split())
ans=0
for i in range(n):
    x,y=map(int,input().split())
    ok=0
    if x>=d or y>=d:
        ok+=1
    elif x**2+y**2 >= d**2:
        ok+=1
    if ok>0:
        ans+=1
print(ans)

Fixed code:
n,d=map(int,input().split())
ans=0
for i in range(n):
    x,y=map(int,input().split())
    ok=0
    if x**2+y**2 <= d**2:
        ok+=1
    if ok>0:
        ans+=1
print(ans)
Buggy code:
c = 0
N, D = map(float(), input().split())
for i in range(int(N)):
  a,b = map(float(), input().split())
  if a**2 + b**2 <= D:
    c+=1
print(c)

Fixed code:
c = 0
N, D = list(map(float, input().split()))
for i in range(int(N)):
    a, b = map(float, input().split())
    if a ** 2 + b ** 2 <= D**2:
        c += 1
print(c)
Buggy code:
import math
n, d = list(map(int, input().split()))
cnt = 0
for i in range(n):
  x, y = list(map(int, input().split()))
  ans = math.sqrt(x*x + y*y)
  if ans>=d:
    cnt+=1
print(cnt)

Fixed code:
import math
n, d = list(map(int, input().split()))
cnt = 0
for i in range(n):
  x, y = list(map(int, input().split()))
  ans = math.sqrt(x*x + y*y)
  #print(ans)
  if ans<=d:
    cnt+=1
print(cnt)
Buggy code:
n,d=map(int,input().split())
cnt=0
for _ in range(n):
  x,y=map(int,input().split())
  
  if (x**2+y**2)>=d**2:
    cnt+=1
print(cnt)

Fixed code:
n,d=map(int,input().split())
cnt=0
for _ in range(n):
  x,y=map(int,input().split())
  
  if (x**2+y**2)<=d**2:
    cnt+=1
print(cnt)
Buggy code:
from math import *

N, D = (int(x) for x in input().split())
count =0
for i in range(N):
    X, Y = (int(x) for x in input().split())
    if sqrt(X*X+Y*Y)<D:
        count+=1

print(count)

Fixed code:
from math import *

N, D = (int(x) for x in input().split())
count =0
for i in range(N):
    X, Y = (int(x) for x in input().split())
    if sqrt(X*X+Y*Y)<=D:
        count+=1

print(count)
Buggy code:
N,D = map(int,input().split())
print(N)
L=[list(map(int,input().split())) for _ in range(N)]
count = 0
for i in L:
    if i[0]**2+i[1]**2<=D**2:
        count+=1
print(count)


Fixed code:
N,D = map(int,input().split())

L=[list(map(int,input().split())) for _ in range(N)]
count = 0
for i in L:
    if i[0]**2+i[1]**2<=D**2:
        count+=1
print(count)
Buggy code:
# -*- coding: utf-8 -*-
n, d = map(int, input().split())
i = 0
num = 0
while i < n:
  x, y = map(int, input().split())
  _d = sqrt((x*x) + (y*y))
  if _d <= d:
    num += 1
  i += 1
 
print(num)

Fixed code:
import math
# -*- coding: utf-8 -*-
n, d = map(int, input().split())
i = 0
num = 0
while i < n:
  x, y = map(int, input().split())
  _d = math.sqrt((x*x) + (y*y))
  if _d <= d:
    num += 1
  i += 1
 
print(num)
Buggy code:
n,d = (int(x) for x in input().split())
count = 0
for i in range(n):
    x,y = (int(x) for x in input().split())
    if x**2*y**2<=d**2:
        count += 1
print(count)

Fixed code:
n,d = (int(x) for x in input().split())
count = 0
for i in range(n):
    x,y = (int(x) for x in input().split())
    if x**2+y**2<=d**2:
        count += 1
print(count)
Buggy code:
i1 = input()
i2 = int(i1.split(" ")[0])
i3 = int(i1.split(" ")[1])
i4 = 0
i5 = 0
i6 = 0
li = []
for i in range(i2):
  i4 = input().split(" ")
  i5 = (int(i4[1]) ** 2 - int(i4[0]) ** 2) ** 0.5
  if (i3 >= i5):
    i6 += 1
print(i6)

Fixed code:
i1 = input()
i2 = int(i1.split(" ")[0])
i3 = int(i1.split(" ")[1])
i4 = 0
i5 = 0
i6 = 0
li = []
for i in range(i2):
  i4 = input().split(" ")
  i5 = (float(i4[1]) ** 2 + float(i4[0]) ** 2) ** 0.5
  if i3 >= abs(i5):
    i6 += 1
print(i6)
Buggy code:
l = [list(map(int,input.split())) for i in range(n)]
N = l[0][0]
D = l[0][1]
count = 0
for i in range(N):
    if l[i+1][0]**2 + l[i+1][1]**2 <= D**2:
        count += 1
print(count)

Fixed code:
i=list(map(int,input().split()))

N=i[0]
D=i[1]

points = [list(map(int,input().split())) for i in range(N)]

count=0

for i in range(N):
    if (points[i][0]**2+points[i][1]**2<=D**2):
        count += 1

print(count)
Buggy code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
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 = 998244353


n, d = LI()
ans = 0
for _ in range(n):
    x, y = LI()
    if x ** 2 + y ** 2 >= d ** 2:
        ans += 1

print(ans)

Fixed code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
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 = 998244353


n, d = LI()
ans = 0
for _ in range(n):
    x, y = LI()
    if x ** 2 + y ** 2 <= d ** 2:
        ans += 1

print(ans)
Buggy code:
n, d = list(map(int, input().split()))
count = 0
for _ in range(n):
  x, y = list(map(int, input().split()))
  if (x**2 + y**2) <= d**2:
    ++count
print(count)

Fixed code:
n, d = list(map(int, input().split()))
count = 0
for _ in range(n):
  x, y = list(map(int, input().split()))
  if (x**2 + y**2) <= d**2:
    count+=1
print(count)
Buggy code:

for i in range(n):
    x,y = map(int,input().split())
    if x**2 + y**2 <= d**2:
        s += 1
print(s)

Fixed code:
n,d = map(int,input().split())

s = 0

for i in range(n):
    x,y = map(int,input().split())
    if x**2 + y**2 <= d**2:
        s += 1
print(s)
Buggy code:
from math importsqrt
n, p = map(int, input().split())
r = 0
for i in range(n):
  x, y = map(int, input().split())
  if sqrt(x*x+y*y) <= p:
    r += 1
print(r)

Fixed code:
from math import sqrt
n, p = map(int, input().split())
r = 0
for i in range(n):
  x, y = map(int, input().split())
  if sqrt(x*x+y*y) <= p:
    r += 1
print(r)
Buggy code:
n, d = list(map(int, input().strip()))
cnt = 0
d2 = d**2
x, y = [], []
for i in range(n):
	tx, ty = list(map(int, input().strip()))
	x.append(tx)
	y.append(ty)

for i in range(n):
	if(x[i]**2 + y[i]**2 <= d2):
		cnt += 1
print(cnt)

Fixed code:
n, d = list(map(int, input().split()))
cnt = 0
d2 = d**2
x, y = [], []
for i in range(n):
	tx, ty = list(map(int, input().split()))
	x.append(tx)
	y.append(ty)

for i in range(n):
	if(x[i]**2 + y[i]**2 <= d2):
		cnt += 1
print(cnt)
Buggy code:
N,D = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
    X,Y = [int(i) for i in input().split()]
    if X^2 + Y^2 <= D:
        ans += 1
print(ans)

Fixed code:
N,D = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
    X,Y = [int(i) for i in input().split()]
    if X**2 + Y**2 <= D**2:
        ans += 1
print(ans)
Buggy code:
N, D = map(int, input().split())
D = D ** 2
ans = 0
for i in range(N) :
    x, y = map(int, input().split())
    if x ** 2 + y ** 2 <= D ** 2 :
        ans += 1
print(ans)

Fixed code:
N, D = map(int, input().split())
D = D ** 2
ans = 0
for i in range(N) :
    x, y = map(int, input().split())
    if x ** 2 + y ** 2 <= D :
        ans += 1
print(ans)
Buggy code:
n, d = map(int, input())
ans = 0
for i in range(n):
  x, y = map(int, input())
  if x**2 + y**2 <= d**2:
    ans += 1
print(ans)

Fixed code:
n, d = map(int, input().split())
ans = 0
for i in range(n):
  x, y = map(int, input().split())
  if x**2 + y**2 <= d**2:
    ans += 1
print(ans)
Buggy code:
n,d = map(int,input().split())
res = 0
for _ in range(n):
  x,y = map(int,input().split())
  if x*x+y*y>=d*d:
    res+=1
print(res)

Fixed code:
n,d = map(int,input().split())
res = 0
for _ in range(n):
  x,y = map(int,input().split())
  if x*x+y*y<=d*d:
    res+=1
print(res)
Buggy code:
N, D = map(int, input().split())
cnt =0
for _ in range(N):
    a, b = map(int, input().split())
    if np.sqrt(a**2+b**2)<=D:
        cnt+=1
print(cnt)

Fixed code:
import numpy as np
N, D = map(int, input().split())
cnt =0
for _ in range(N):
    a, b = map(int, input().split())
    if np.sqrt(a**2+b**2)<=D:
        cnt+=1
print(cnt)
Buggy code:
import datetime
import string
import re
import math

inp = list(map(int, input().split()))
N=int(inp[0])
D=int(inp[1])
alist = [input().split() for i in range(N)]

count = 0
for i in range(N):
    if int(alist[i][0])^2 + int(alist[i][1])^2 <= D^2: count += 1

print(count)

Fixed code:
import datetime
import string
import re
import math

inp = list(map(int, input().split()))
N=int(inp[0])
D=int(inp[1])
alist = [input().split() for i in range(N)]

count = 0
for i in range(N):
    if int(alist[i][0])**2 + int(alist[i][1])**2 <= D**2: count += 1

print(count)
Buggy code:
import math
N,D = map(int,input().split())
count=0
for i in range(N):
  X,Y = map(int,input().split())
  a = math.sqrt(X**2+Y**2)
  if int(a) == D:
    count+=1
print(count)

Fixed code:
import math
N,D = map(int,input().split())
count=0
for i in range(N):
  X,Y = map(int,input().split())
  a = math.sqrt(X**2+Y**2)
  if a <= float(D):
    count+=1
print(count)
Buggy code:
N,D = map(int,input().split())
t=0
for i in range(N):
    X,Y = map(int,input().split())
    if (X**2+Y**2)<D**2:
        t=t+1
    else:
        t=t
print(t)

Fixed code:
N,D = map(int,input().split())
t=0
for i in range(N):
    X,Y = map(int,input().split())
    if (X**2+Y**2)<=D**2:
        t=t+1
    else:
        t=t
print(t)
Buggy code:
N,D = (int(x) for x in input().split())
count = 0
for i in range(N):
  x,y = (int(z) for z in input().split())
  sqdist = x**2 + y**2
  if sqdist < D**2:
    count += 1
print(count)

Fixed code:
N,D = (int(x) for x in input().split())
count = 0
for i in range(N):
  x,y = (int(z) for z in input().split())
  dist = x**2 + y**2
  if dist <= D**2:
    count += 1
print(count)
Buggy code:
n,m = map(int,input().split())
for i in range(n):
  p1,p2 = map(int,input().split())
  cnt = 0
  t = ((p1*p1)(p2*p2))**(0.5)
  if t >= m:
    cnt += 1
  print(cnt)

Fixed code:
n,m = map(int,input().split())
cnt = 0
for i in range(n):
    
    p1,p2 = map(int,input().split())
    t = ((p1*p1)+(p2*p2))**(0.5)
    if t <= m:
        cnt += 1
    
print(cnt)