qyliang/CodeNanoFix huggingface dataset:
Buggy code:
N,D=input().split()
N=int(N)
D=int(D)
cnt = 0
for i in range(N):
  
    
  p1,p2 = map(int,input().split())
  t = ((p1*p1)(p2*p2))**(0.5)
  if t >= D:
    
    cnt += 1
    
print(cnt)

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

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

kyori = d * d
count = 0

for s in range(n):
  nagasa = p[s][0] * p[s][0] + p[s][1] * p[s][1]
  if nagasa <= kyori:
    count += 1
    
print(count)

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

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

kyori = d * d
count = 0

for s in range(n):
  nagasa = p[s][0] * p[s][0] + p[s][1] * p[s][1]
  if nagasa <= kyori:
    count += 1
    
print(count)
Buggy code:
n,d = map(int,input().split())
cnt = 0
for i in raneg(n):
    p,q = map(int,input().split())
    cnt += p*p+q*q <= d*d
print(cnt)

Fixed code:
n,d = map(int,input().split())
cnt = 0
for i in range(n):
    p,q = map(int,input().split())
    cnt += p*p+q*q <= d*d
print(cnt)
Buggy code:
N, D = map(int, input().split())
A = 0
for point in range(N):
    p, q = map(int, input().split())
    dis = q**2 + q**2
    if(dis <= D**2):   
        A += 1

print (A)

Fixed code:
N, D = map(int, input().split())
A = 0
for point in range(N):
    p, q = map(int, input().split())
    dis = p**2 + q**2
    if(dis <= D**2):   
        A += 1

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


Fixed code:
n,d=map(int,input().split())
ans=0
for _ in range(n):
    x,y=map(int,input().split())
    if x**2+y**2<=d**2:
        ans+=1
print(ans)
Buggy code:
import sys
def Ii():return int(sys.stdin.readline())
def Mi():return map(int,sys.stdin.readline().split())
def Li():return list(map(int,sys.stdin.readline().split()))

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

Fixed code:
import sys
def Ii():return int(sys.stdin.readline())
def Mi():return map(int,sys.stdin.readline().split())
def Li():return list(map(int,sys.stdin.readline().split()))

ans = 0
n,d = Mi()
d = d*d
for i in range(n):
  x,y = Mi()
  if d >= x**2+y**2:
    ans += 1
print(ans)
Buggy code:
N,D=input().split(" ")
count=0
for n in range(int(N)):
  x,y=input().split(" ")
  if pow(pow(x,2)+pow(y,2),0.5)<=int(D):
    count+=1
print(count)


Fixed code:
N,D=input().split(" ")
count=0
for n in range(int(N)):
  x,y=input().split(" ")
  if pow(pow(int(x),2)+pow(int(y),2),0.5)<=int(D):
    count+=1
print(count)
Buggy code:
N,D=map(int,input().split())
sum=0
for _ in range(N):
    X,Y=map(int,input().split())
    if math.sqrt(((X*X)+(Y*Y)))<=D:
        sum=sum+1
    print(sum)
    

Fixed code:
import math

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

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

print(N+D)
Df = [0]*N

for i in range(N):
  x,y = map(float,input().split())
  if math.sqrt(x*2 + y*2) >= D:
    Df[i] = 1

print(Df.count(1))

Fixed code:
import math

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

Df = [0]*N

for i in range(N):
  x,y = map(float,input().split())
  if math.sqrt(x*x + y*y) <= D:
    Df[i] = 1

print(Df.count(1))
Buggy code:
from math import*
m,n=input().split(" ")
c=0
for i in range(int(m)):
  a,b=input().split(" ")
  d=(int(a)**2)+(int(b)**2)
  if sqrt(d)>=int(n):
    c=c+1
print(c)

Fixed code:
from math import*
m,n=input().split()
c=0
for i in range(int(m)):
  a,b=input().split()
  d=(int(a)**2)+(int(b)**2)
  if sqrt(d)<=int(n):
    c=c+1
print(c)
Buggy code:
N, D = map(int, input())

# pts = [tuple(map(int, input())) for _ in range(N)]

ans = 0
if _ 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(' '))

# pts = [tuple(map(int, input())) for _ in range(N)]

ans = 0
for _ in range(N):
  x, y = map(int, input().split(' '))
  if x**2 + y**2 <= D**2:
    ans+=1
    
print(ans)
Buggy code:
import math

n,d = map(int, input().split())
count = 0
for i in range(n):
  x,y = map(int, input().split())
  dis = math.sqrt((x**2)+(y**2))
  if dis >= 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())
  dis = math.sqrt((x**2)+(y**2))

  if dis <= d:
    count += 1

    
print(count)
Buggy code:
N, D = map(int, input().split())

X = [0] * N
Y = [0] * N

for i in range(N):
    X[i], Y[i] = map(int, input.split())

count = 0

for i in range(N):
    if(D**2 >= X[i]**2 + Y[i]**2):
        count += 1

print(count)




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

X = [0] * N
Y = [0] * N

for i in range(N):
    X[i], Y[i] = map(int, input().split())

count = 0

for i in range(N):
    if(D**2 >= X[i]**2 + Y[i]**2):
        count += 1

print(count)
Buggy code:
import math

N, D = map(int, input().split())
count = 0
for _ in range(M):
    x, y = map(int, input().split())
    xx = x ** 2
    yy = y ** 2

    ans = math.sqrt(xx + yy)
    if ans >= D:
        count += 1

print(count)

Fixed code:
import math

N, D = map(int, input().split())
count = 0
for _ in range(N):
    x, y = map(int, input().split())
    xx = x ** 2
    yy = y ** 2

    ans = math.sqrt(xx + yy)
    if ans <= D:
        count += 1

print(count)
Buggy code:
from sys import stdin
input = stdin.buffer.readline
n, d = map(int, input().split())
r = 0
for _ in range(n):
    x, y = map(int, input().split())
    r += x * x + y * y >= d * d
print(r)


Fixed code:
from sys import stdin
input = stdin.buffer.readline
n, d = map(int, input().split())
r = 0
for _ in range(n):
    x, y = map(int, input().split())
    r += x * x + y * y <= d * d
print(r)
Buggy code:
n,d=map(int,input().split())
k=0
for i in range(n):
  x,y=map(int,input().split())
  if x**2+y**2<=d:k+=1
print(k)

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

cnt = 0
for i in range(n):
    x, y = map(int, input().split())
    if x**2 + y**2 <= d**2:
        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 D::2>=X**2+y**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 D**2>=X**2+Y**2:
        ans +=1

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

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

w = input()
total = 0
x = 0
y = 0


n = w[0]
d = w[2]
n = int(n)
d = float(d)


for x in range(n):
    w = input()

    i = w.index(' ')
    y = w[0:i]
    x = w[(i+1):]

    x = int(x)
    y = int(y)

    if math.sqrt((x*x)+(y*y)) <= d:
        total = total+1

print (total)

Fixed code:
import math

w = input()
total = 0
x = 0
y = 0


i = w.index(' ')
n = w[0:i]
d = w[(i+1):]
n = int(n)
d = float(d)


for x in range(n):
    w = input()

    i = w.index(' ')
    y = w[0:i]
    x = w[(i+1):]

    x = int(x)
    y = int(y)

    if math.sqrt((x*x)+(y*y)) <= d:
        total = total+1

print (total)
Buggy code:
N, D = map(int, input().split())
count = 0
D_2 = D*D
for _ in range(N):
    x, y = map(int, input().split())
    d = x*x + y*y
    print(d)
    if d <= D_2:
        count +=1
print(count)

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

for i in z:
    distance = i[0]*i[0] + i[1]*i[1]
    if distance <= d**2:
        ans += 1
        print(i, distance)

print(ans)

Fixed code:
n,d = map(int, input().split())
z = [list(map(int, input().split())) for _ in range(n)]
ans = 0

for i in z:
    distance = i[0]*i[0] + i[1]*i[1]
    if distance <= d**2:
        ans += 1

print(ans)
Buggy code:
n,d = map(int,input().split())
ans = 0
import numpy as np
for i in range(n):
  x,y = map(int,input().split())
  if np.norm(np.array([x,y]),ord=2) <= d:
    ans+=1
    
print(ans)

Fixed code:
n,d = map(int,input().split())
ans = 0
import numpy as np
for i in range(n):
  x,y = map(int,input().split())
  if np.linalg.norm(np.array([x,y]),ord=2) <= d:
    ans+=1
    
print(ans)
Buggy code:
N,D = map(int,input().split())
ans = 0
for i in range(N):
  num1,num2 = map(float,input().split())
  if (num1 ** 2 + num2 ** 2) ** (1 / 2) < D:
    ans += 1

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

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

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

for i in  range(N):
    x,y=map(int,input().split())
    if(D*D>=x*x+y*y):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(D*D>=x*x+y*y):ans+=1
     
print(ans)
Buggy code:
n, d = map(int, input().split(" "))
p = []
ans = 0
for i in range(n):
    p.append(list(map(int, input().split(" "))))

for i, [x, y] in enumerate(p):
    if(x >= d or y >= d):
        continue
    if(x**2 + y**2 <= d**2):
        ans += 1


print(ans)


Fixed code:
n, d = map(int, input().split(" "))
p = []
ans = 0
for i in range(n):
    p.append(list(map(int, input().split(" "))))

for i, [x, y] in enumerate(p):
    if(x > d or y > d):
        continue
    if(x**2 + y**2 <= d**2):
        ans += 1


print(ans)
Buggy code:
N , D = map(int,input().split())

c = 0
for i in range(N):
    x , y = map(int,input().split())

    z = (x**2+y**2)**0.5

    print(z)

    if D <= z:
        c+=1
        print(c)

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

c = 0
for i in range(N):
    x , y = map(int,input().split())

    z = (x**2+y**2)**0.5

    # print(z)

    if D >= z:
        c+=1
print(c)
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*T <= D*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:
import numpy

N, D = map(int, input().split())
X = [0] * N
Y = [0] * N
count = 0
for i in range(N):
    X[i], Y[i] = map(int, input().split())
    if numpy.sqrt(X[i]**2 + Y[i]**2):
        count += 1
print(count)

Fixed code:
import numpy

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


param_n, param_d = map(int, input().split())

param_count = 0
for i in param_n:
    param_a, param_b = map(int, input().split())
    
    if (param_a)*(param_a) + (param_b)*(param_b) <= (param_d)*(param_d):
        param_count = param_count + 1
        
print(param_count)

Fixed code:
param_n, param_d = map(int, input().split())

param_count = 0
for i in range(param_n):
    param_a, param_b = map(int, input().split())
    
    if (param_a)*(param_a) + (param_b)*(param_b) <= (param_d)*(param_d):
        param_count = param_count + 1
        
print(param_count)
Buggy code:
n, d = map(int, input().split())

ans = 0
for i in range(n):
    x, y = map(int, input())
    if x ** 2 + y ** 2 <= d:
        ans += 1

print(ans)

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

Fixed code:
from math import sqrt
c = 0
N ,D = map(int,input().split())
for i in range(N):
    x, y = map(int, input().split())
    T = sqrt(x**2 + y**2)
    if T <= round(D):
        c = c+1
print(c)
Buggy code:
import math

def dist(x, y):
    return math.sqrt(x^2+y^2)

# in_values = input()

l = list(map(int, input().split()))
n = l[0]
d = l[1]

count = 0
for _ in range(n):
    l = list(map(int, input().split()))
    if dist(l[0], l[1]) <= d:
        count+=1

print(count)

Fixed code:
import math

def dist(x, y):
    return math.sqrt(x**2+y**2)

# in_values = input()

l = list(map(int, input().split()))
n = l[0]
d = l[1]

count = 0
for _ in range(n):
    l = list(map(int, input().split()))
    if dist(l[0], l[1]) <= d:
        count+=1

print(count)
Buggy code:
import math

N, D = map(int, input().split())
ans = 0

for i in range(N):
    x, y = map(int, input().split())
    if math.sqrt(x**2 + y**2) =< D:
        ans += 1

print(ans)

Fixed code:
import math

N, D = map(int, input().split())
ans = 0

for i in range(N):
    x, y = map(int, input().split())
    if math.sqrt(x**2 + y**2) <= D:
        ans += 1

print(ans)
Buggy code:
import math

N,D = map(int,input().split())
cnt = 0
for n in range(N):
    a,b = map(int,input().split())
    if sqrt(a**2 + b**2)-D>=0:
        cnt+=1
print(cnt)

Fixed code:
import math

N,D = map(int,input().split())
cnt = 0
for n in range(N):
    a,b = map(int,input().split())
    if math.sqrt(a**2 + b**2)-D<=0:
        cnt+=1
print(cnt)
Buggy code:
from math import *
n,d=map(int,input().split())
k=d*d
ans=0
for i in range(n):
    x,y=map(int,input().split())
    x1=x**2
    y1=y**2
    m=x1+y1
    if m>=k:
        ans=ans+1
print(ans)

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

ans = 0

for _ in range(N):
  p,q = map(int,input().split())
  if p**2+q**2 < D**2:
    ans+=1
print(ans)

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

ans = 0

for _ in range(N):
  p,q = map(int,input().split())
  if p**2+q**2 <= D**2:
    ans+=1
print(ans)
Buggy code:
N,D=(int(x) for x in input().split())
xy = [map(int, input().split()) for _ in range(N)]
x, y = [list(i) for i in zip(*xy)]


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

Fixed code:
N,D=(int(x) for x in input().split())
xy = [map(int, input().split()) for _ in range(N)]
x, y = [list(i) for i in zip(*xy)]


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

for i in range(N):
  if (X[i][0])**2 + (X[i][1])**2 - D**2 >= 0:
    count = count + 1
    
print(count)

Fixed code:
N, D = map(int, input().split())
X = [list(map(int, input().split())) for l in range(N)]
count = 0

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


Fixed code:
N, D = map(int, input().split())
an=0
for i in range(N):
  X, Y= map(int, input().split())
  if X**2+Y**2<=D**2:
    an +=1
print(an)
Buggy code:
def main():
    n, d = map(int, input().split())
    is_shorter = lambda dis, x, y : dis**2 <= (x**2 + y**2)
    ans = sum([is_shorter(d, map(int, input().split())) for _ in range(n)])
    print(ans)

if __name__ == "__main__":
    main()

Fixed code:
def main():
    n, d = map(int, input().split())
    is_shorter = lambda dis, x, y : (x**2 + y**2) <= dis**2
    ans = sum([is_shorter(d, *map(int, input().split())) for _ in range(n)])
    print(ans)

if __name__ == "__main__":
    main()
Buggy code:
x,y = map(int,input().split())
y =y**2
count=0
for i in range(x):
    a,b = map(int,input().split())	
    if a**2+b**2 <y:
        count+=1;
print(count)

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

for i in range(N):
  if(x[i]**2 + y[i]**2 <= D**2):
    n += 1

print(n)

Fixed code:
N,D =(int(x) for x in input().split())
xy = [map(int,input().split()) for _ in range(N)]
x,y = [list(i) for i in zip(*xy)]
n = 0
 
for i in range(N):
  if(x[i]**2 + y[i]**2 <= D**2):
    n += 1
 
print(n)
Buggy code:
#b
N, D = map(int, input().split())
x = [0] * N
y = [0] * N
for i in range(N):
     x[i], y[i] = map(int, input().split())
ans=0        
for i in range(N):
    h=x[i]**2+y[i]**2
    if h>=D**2:
        ans+=1
print(ans)

Fixed code:
#b
N, D = map(int, input().split())
x = [0] * N
y = [0] * N
for i in range(N):
     x[i], y[i] = map(int, input().split())
ans=0        
for i in range(N):
    h=x[i]**2+y[i]**2
    if h<=D**2:
        ans+=1
print(ans)
Buggy code:
import math
n,d=map(int,input().split())
l==[list(map(int,input().split())) for _ in range(n)]
c=0
for i in range(n):
    x=l[i][0]
    y=l[i][1]
    k=math.sqrt(x**2+y**2)
    if k<=d:c+=1
print(c)

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

while(N--):
  Z1 = list(input(""))
  X = int(Z[0])
  Y = int(Z[1])
  
  d = (X**2 + Y**2)**0.5
  
  if d<=D:
    count += 1
    
print(count)    

Fixed code:
Z = input("").split()
N = int(Z[0])
D = int(Z[1])
count = 0
 
while(N):
    Z1 = input("").split()
    X = int(Z1[0])
    Y = int(Z1[1])
  
    d = (X**2 + Y**2)**0.5
  
    if d<=D:
        count += 1
    N = N -1
print(count)
Buggy code:
import math

N, D = input().split()

x = [0] * N
y = [0] * N

for i in range(N):
  x[i], y[i] = map(int, input().split())
  
counter = 0

for i in range(N):
  dist = x[i] * x[i] + y[i] * y[i]
  if dist <= D:
    counter += 1

print(counter)

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

x = [0] * N
y = [0] * N

for i in range(N):
  x[i], y[i] = map(int, input().split())
  
counter = 0

for i in range(N):
  dist = x[i] * x[i] + y[i] * y[i]
  if dist <= D*D:
    counter += 1

print(counter)
Buggy code:
import math

n,d = map(int,input().split(' '))
x,y = [0]*n,[0]*n
for i in range(n):
  x[i],y[i] = map(int,input().split(' '))
  
ans = 0  
  
for i in range(n):
  distane = math.sqrt(x[i]*x[i] + y[i]*y[i])
  if distane >= d:
      ans += 1
print(ans)

Fixed code:
import math

n,d = map(int,input().split(' '))
x,y = [0]*n,[0]*n
for i in range(n):
  x[i],y[i] = map(int,input().split(' '))
  
ans = 0  
  
for i in range(n):
  distane = math.sqrt(x[i]*x[i] + y[i]*y[i])
  if distane <= d:
      ans += 1
print(ans)
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) <= D**2:
    ans +=1
  else:
    ans +=0

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
  else:
    ans +=0

print(ans)
Buggy code:
import math
n,d=map(int,input().split())
xy=[map(int,input().split()) for _ in range(n)]
x,y=[list(i) for i in zip(*xy)]
count=0

for i in range(n):
    if math.sqrt((x[i]*x[i])*(y[i]*y[i]))>=d:
        count=count+1   

print(count)


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

for i in range(n):
    a=math.sqrt((x[i]*x[i])+(y[i]*y[i]))
    if d>=a:
        count=count+1   

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

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

Fixed code:
import math
N,D=map(int, input().split())
count=0
for _ in range(N):
    X,Y=map(int, input().split())
    if math.sqrt(X**2 + Y**2) <= D:
        count += 1
print(count)
Buggy code:
n,d = map(int,input().split())
count = 0
for _ in range(n):
    x, y = map(int,input().split())
    if (x**2 + y**2)**(0.5) >= d:
        count += 1

print(count)

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

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

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

count = 0
n, d = map(int, input().split())

for _ in range(n):
    x1, x2 = map(int, input().split())
    x = math.sqrt(x1 ** 2 + x2 ** 2)
    if x >= d:
        count += 1
    
print(count)

Fixed code:
import math

count = 0
n, d = map(int, input().split())

for _ in range(n):
    x1, x2 = map(int, input().split())
    x = math.sqrt(x1 ** 2 + x2 ** 2)
    if x <= d:
        count += 1
    
print(count)
Buggy code:
import math

num, dist = map(int, input().split())
count = 0
for i in range(0,num):
    x, y = map(int, input().split())
    distance = math.sqrt(x**2 + y**2)
    if distance >= dist:
        count += 1

print(count)

Fixed code:
import math

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

print(count)
Buggy code:
n, d = map(int, input().split())

xy = [map(int, input().split()) for _ in range(5)]
x, y = [list(i) for i in zip(*xy)]


count = 0

for i, j in zip(x, y):
    if i*i + j*j <= d*d:
        count += 1

print(count)

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

xy = [map(int, input().split()) for _ in range(n)]
x, y = [list(i) for i in zip(*xy)]

count = 0

for i, j in zip(x, y):
    if i*i + j*j <= d*d:
        count += 1

print(count)
Buggy code:
import math
n,d=map(int,input().split(' '))
cnt=0
while n>0:
    x,y=map(int,input().split(' '))
    res=math.sqrt(x**2+y**2)
    if res<=d:
        cnt+=1
print(cnt)


Fixed code:
import math
n,d=map(int,input().split(' '))
cnt=0
while n>0:
    x,y=map(int,input().split(' '))
    res=math.sqrt(x**2+y**2)
    if res<=d:
        cnt+=1
    n=n-1
print(cnt)
Buggy code:
import math

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


Fixed code:
import math

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

cnt = 0
for i in range(n):
  x, y = map(int, input().split())
  if d * d > x * x + y * y:
    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 d * d >= x * x + y * y:
    cnt += 1

print(cnt)