qyliang/CodeNanoFix huggingface dataset:
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
X = abs(x1 - x2)
Y = abs(y1 - y2)

if x1 < x2 or y1 < y2:
  x3, y3 = x2 - Y, y2 + X
  x4, y4 = x3 - X, y3 - Y
else:
  x3, y3 = x2 + Y, y2 - X
  x4, y4 = x3 + X, y3 + Y

print(x3, y3, x4, y4)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
X = x2 - x1
Y = y2 - y1

if x2 > x1 or y2 > y1:
  x3, y3 = x2 - Y, y2 + X
  x4, y4 = x3 - X, y3 - Y

else:
  x3, y3 = x2 + abs(Y), y2 + X
  x4, y4 = x3 - X, y3 + abs(Y)

print(x3, y3, x4, y4)
Buggy code:
import sys

input = sys.stdin.readline


def main():
    x1, y1, x2, y2 = map(int, input().split())
    x, y = x2 - x1, y2 - y1
    print(x2 - y, y2 + x, x1 - y, y2 - x)
    # print(" ".join([x1 - x, y1, x2, y2]))


if __name__ == "__main__":
    main()


Fixed code:
import sys

input = sys.stdin.readline


def main():
    x1, y1, x2, y2 = map(int, input().split())
    x, y = x1 - x2, y1 - y2
    print(x2 + y, y2 - x, x1 + y, y1 - x)
    # print(" ".join([x1 - x, y1, x2, y2]))


if __name__ == "__main__":
    main()
Buggy code:
x, y, xx, yy = input().split()
x = int(x)
y = int(y)
xx = int(xx)
yy = int(yy)

xdiff = (xx-x)
ydiff = (yy-y)

if xdiff < 0 and ydiff < 0:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy-xdiff),str(x+ydiff),str(y-xdiff))
elif 0 < xdiff and 0 < ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy+xdiff),str(x-ydiff),str(y+xdiff))
elif xdiff < 0 and 0 < ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy-xdiff),str(x-ydiff),str(y-xdiff))
else:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy+xdiff),str(x+ydiff),str(y+xdiff))

Fixed code:
x, y, xx, yy = input().split()
x = int(x)
y = int(y)
xx = int(xx)
yy = int(yy)

xdiff = (xx-x)
ydiff = (yy-y)

if xdiff <= 0 and ydiff <= 0:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy-xdiff),str(x+ydiff),str(y-xdiff))
elif 0 <= xdiff and 0 <= ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy+xdiff),str(x-ydiff),str(y+xdiff))
elif xdiff <= 0 and 0 <= ydiff:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx-ydiff),str(yy-xdiff),str(x-ydiff),str(y-xdiff))
else:
    xdiff = abs(xx-x)
    ydiff = abs(yy-y)
    print(str(xx+ydiff),str(yy+xdiff),str(x+ydiff),str(y+xdiff))
Buggy code:
a,b,c,d = map(int,input().split())

x = a-(d-b)
y = b+(c-a)
z = x+(c-a)
w = y+(d-b)

print(x,y,z,w)


Fixed code:
a,b,c,d = map(int,input().split())

x = a-(d-b)
y = b+(c-a)
z = x+(c-a)
w = y+(d-b)

print(z,w,x,y)
Buggy code:
x1,y1,x2,y2 = map(int,input().split())
x3 = x2 - y2 + y1
y3 = x2 - y2 + x1
x4 = x1 - y2 + y1
y4 = y1 - x1 + x2
print(x3,y3,x4,y4)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
x_len = x1 - x2
y_len = y1 - y2

x3 = x2 + y_len
y3 = y2 - x_len
x4 = x3 + x_len
y4 = y3 + y_len

print(x3, y3, x4, y4)
Buggy code:
x1,y1,x2,y2 = map(int,input().split())

dx = x1 - x2 #-4
dy = y1 - y2 #-3

x3,y3 = x2 - dy,y2 - dx
x4,y4 = x3 + dx,y3 + dy

print(x3,y3,x4,y4)

Fixed code:
x1,y1,x2,y2 = map(int,input().split())

dx = x1 - x2 #-4
dy = y1 - y2 #-3

x3,y3 = x2 + dy,y2 - dx
x4,y4 = x3 + dx,y3 + dy

print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
x = x2 - x1
y = y2 - y1
x3 = x2 - y
y3 = y2 + x
x4 = y1 - y
y4 = y1 + x
print(x3, y3, x4, y4)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
x = x2 - x1
y = y2 - y1
x3 = x2 - y
y3 = y2 + x
x4 = x1 - y
y4 = y1 + x
print(x3, y3, x4, y4)
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, end='')
print(y2+x2-x1, end='')
print(x2-y2+y1-x2+x1, end='')
print(y2+x2-x1-y2+y1, end='')

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, end=' ')
print(y2+x2-x1, end=' ')
print(x2-y2+y1-x2+x1, end=' ')
print(y2+x2-x1-y2+y1, end='')
Buggy code:
import math

x1,y1,x2,y2=map(int, input().split())

#line = math.sqrt(pow(x2-x1,2)+pow(y2-y1,2))

buf1=x2-x1
buf2=y2-y1

print(buf1,buf2)

print(x2-buf2,y2+buf1,x1-buf2,y1+buf1)

Fixed code:
import math

x1,y1,x2,y2=map(int, input().split())

#line = math.sqrt(pow(x2-x1,2)+pow(y2-y1,2))

buf1=x2-x1
buf2=y2-y1

print(x2-buf2,y2+buf1,x1-buf2,y1+buf1)
Buggy code:
x0, y0, x1, y1 = [int(x) for x in input().split()]
dx = x1 - x0
dy = y1 - y0
print(x1 + dy, y1 - dx)
print(x0 + dy, y0 - dx)


Fixed code:
x0, y0, x1, y1 = [int(x) for x in input().split()]
dx = x1 - x0
dy = y1 - y0
print(x1 - dy, y1 + dx, x0 - dy, y0 + dx)
Buggy code:
x1,y1,x2,y2 = map(int,input().split())
x3 = x2 + y1 - y2
y3 = y2 + x2 - x1
x4 = x1 + y1 - y2
y4 = y1 + x2 - x1
print("x3","","y3","","x4","","y4")

Fixed code:
x1,y1,x2,y2 = map(int,input().split())
x3 = x2 + y1 - y2
y3 = y2 + x2 - x1
x4 = x1 + y1 - y2
y4 = y1 + x2 - x1
print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = list(map(int, input().split()))
vector = (x2-x1, y2-y1)
x3, y3 = x1-vector[1], y1+vector[0]
x4, y4 = x2-vector[1], y2+vector[0]
print(x3, y3, x4, y4)

Fixed code:
x1, y1, x2, y2 = list(map(int, input().split()))
vector = (x2-x1, y2-y1)
x3, y3 = x2-vector[1], y2+vector[0]
x4, y4 = x1-vector[1], y1+vector[0]
print(x3, y3, x4, y4)
Buggy code:
nums = list(map(int, input().split()))
x = abs(nums[0] - nums[2])
y = abs(nums[1] - nums[3])
# kyori = sqrt((x*x) + (y*y))
n1 = nums[2] - y
n2 = nums[3] + x
print(n1, end="")
print(" ", end="")
print(n2, end="")
print(" ", end="")
print(n1 - x, end="")
print(" ", end="")
print(n2 - y, end="")
print(" ", end="")

Fixed code:
nums = list(map(int, input().split()))
x = (nums[2] - nums[0])
y = (nums[3] - nums[1])
# kyori = sqrt((x*x) + (y*y))
n1 = nums[2] - y
n2 = nums[3] + x
print(n1, end="")
print(" ", end="")
print(n2, end="")
print(" ", end="")
print(n1 - x, end="")
print(" ", end="")
print(n2 - y)
Buggy code:
x1,y1,x2,y2 = map(int,input().split())
k = abs(y2-y1)
m = abs(x2-x1)
print(x2-k,y2+m,x1-k,y1+m)

Fixed code:
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)
Buggy code:
x1,y1,x2,y2 = map(int, input().split())
#print(x1,y1,x2,y2)
X = x2 - x1
Y = y2 - y1
print(x2-Y,y2-X,x2-Y-X,y2-X-Y)








Fixed code:
x1,y1,x2,y2 = map(int, input().split())
#print(x1,y1,x2,y2)
X = x2 - x1
Y = y2 - y1
print(x2-Y,y2+X,x2-Y-X,y2+X-Y)
Buggy code:
x1,y1,x2,y2 = map(int,input().split())

a1 = x2 - x1
a2 = y2 - y1

x3 = x2 + (-a2)
y3 = x2 + (a1)

x4 = x3 + (-a1)
y4 = y3 + (-a2)

print(x3,y3,x4,y4)


Fixed code:
x1, y1, x2, y2 = map(int, input().split())
x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x3 - (x2 - x1)
y4 = y3 - (y2 - y1)
print(x3, y3, x4, y4)
Buggy code:
x1 , y1, x2, y2 = map(int, input().split())

x3 = x2 - ( y2 - y1)
y3 = y2
x4 = x3
y4 = y1

print(x3, y3, x4, y4, sep = " ")

Fixed code:
x1 , y1, x2, y2 = map(int, input().split())

x3 = x2 - (y2 - y1)
y3 = y2 + (x2 - x1)
x4 = x3 - (x2 - x1)
y4 = y3 - (y2 - y1) 
print(x3, y3, x4, y4, sep = " ")
Buggy code:
A=input()
A=A.rstrip().split(" ")
x1=int(A[0])
y1=int(A[1])
x2=int(A[2])
y2=int(A[3])
#print(x1,y1,x2,y2)
x3=x2+(y1-y2)
y3=y2+(x2-x1)
x4=x1+(y2-y3)
y4=y1+(x2-x1)
print(x3,y3,x4,y4)

Fixed code:
A=input()
A=A.rstrip().split(" ")
x1=int(A[0])
y1=int(A[1])
x2=int(A[2])
y2=int(A[3])
#print(x1,y1,x2,y2)
x3=x2+(y1-y2)
y3=y2+(x2-x1)
x4=x1-(y2-y1)
y4=y1+(x2-x1)
print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int,input().split())

a, b = x2 - x1, y2 - y1
x3, y3 = x2 - a, y2 - b
x4, y4 = x1 - b, y1 - a

print(x3,y3,x4,y4)

Fixed code:
x1, y1, x2, y2 = map(int,input().split())

a, b = x2 - x1, y2 - y1
x3, y3 = x2 - b, y2 + a
x4, y4 = x3 - a, y3 - b

print(x3, y3, x4, y4)
Buggy code:
a = list(map(int, input().split(" ")))
print(a)

p1 = (a[0], a[1])
p2 = (a[2], a[3])

dif = (p2[0]-p1[0], p2[1]-p1[1])

p3 = (p2[0]-dif[1], p2[1]+dif[0])
p4 = (p3[0]-dif[0], p3[1]-dif[1])

print(p3[0], p3[1], p4[0], p4[1])

Fixed code:
a = list(map(int, input().split(" ")))
 
p1 = (a[0], a[1])
p2 = (a[2], a[3])
 
dif = (p2[0]-p1[0], p2[1]-p1[1])
 
p3 = (p2[0]-dif[1], p2[1]+dif[0])
p4 = (p3[0]-dif[0], p3[1]-dif[1])
 
print(p3[0], p3[1], p4[0], p4[1])
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
x = x1-x2
y = y2-y1
print(x2-y, y2+x , x1-y, y1-x)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
x = x1-x2
y = y2-y1
print(x2-y, y2-x , x1-y, y1-x)
Buggy code:
n = list(map(int, input().split()))

a,b = (n[2] - n[0]), (n[3] - n[1])

o1,o2 = (n[2] - b), (n[3] + a)
o3,o4 = (o1 - a),(o2 - b)

print(" ".join([o1,o2,o3,o4]))

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

a,b = (n[2] - n[0]), (n[3] - n[1])

o1,o2 = (n[2] - b), (n[3] + a)
o3,o4 = (o1 - a),(o2 - b)

print(" ".join(list(map(str, [o1,o2,o3,o4]))))
Buggy code:
a, b, c, d = map(int, input().split())

x ,y = c - a, d - b
print(a - y, b + x, c - y , c + x)

Fixed code:
a, b, c, d = map(int, input().split())

x ,y = c - a, d - b
print(c - y, d + x, a - y , b + x)
Buggy code:
# cook your dish here
import numpy as np
if __name__ == '__main__':
    xy = [int(i) for i in input().split()]
    a1 = np.array([xy[0], xy[1]])
    a2 = np.array([xy[2], xy[3]])
    b = a2 - a1
    r = np.pi / 2
    rot = np.matrix((
        (np.cos(r), np.sin(r)),
        (-np.sin(r), np.cos(r))
    ))
    c = np.dot(b, rot)
    a3 = a2+c
    a4 = a1+c
    print('{} {} {} {}'.format(np.round(a3[0,0]), np.round(a3[0,1]), np.round(a4[0,0]), np.round(a4[0,1])))


Fixed code:
# cook your dish here
import numpy as np
if __name__ == '__main__':
    xy = [int(i) for i in input().split()]
    a1 = np.array([xy[0], xy[1]])
    a2 = np.array([xy[2], xy[3]])
    b = a2 - a1
    r = np.pi / 2
    rot = np.matrix((
        (np.cos(r), np.sin(r)),
        (-np.sin(r), np.cos(r))
    ))
    c = np.dot(b, rot)
    a3 = a2+c
    a4 = a1+c
    print('{} {} {} {}'.format(int(np.round(a3[0,0])), int(np.round(a3[0,1])), int(np.round(a4[0,0])), int(np.round(a4[0,1]))))
Buggy code:
x1,y1,x2,y2 = map(int,input().split())
xsa = x2 - x1
ysa = y2 - y1
x3 = x2 - ysa
y3 = y2 + xsa
x4 = x1 - ysa
y4 = y1 + xsa
print(x3,end="")
print(y3,end="")
print(x4,end="")
print(y4)

Fixed code:
x1,y1,x2,y2 = map(int,input().split())
xsa = x2 - x1
ysa = y2 - y1
x3 = x2 - ysa
y3 = y2 + xsa
x4 = x1 - ysa
y4 = y1 + xsa
print(x3,end=" ")
print(y3,end=" ")
print(x4,end=" ")
print(y4)
Buggy code:
1, y1, x2, y2 = list(map(int, input().split()))

xx = x2 - x1
yy = y2 - y1

x3 = x2 - yy
y3 = y2 + xx
x4 = x3 - xx
y4 = y3 - yy

print(x3, y3, x4, y4)

Fixed code:
x1, y1, x2, y2 = list(map(int, input().split()))

xx = x2 - x1
yy = y2 - y1

x3 = x2 - yy
y3 = y2 + xx
x4 = x3 - xx
y4 = y3 - yy

print(x3, y3, x4, y4)
Buggy code:
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":
    x1,y1,x2,y2 = I2()
    v = x2 - x1#x
    w = y2 - y1#y
    print(x2-w,y2+v,x1-w,y2+v)

Fixed code:
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":
    x1,y1,x2,y2 = I2()
    v = x2 - x1#x
    w = y2 - y1#y
    print(x2-w,y2+v,x1-w,y1+v)
Buggy code:
x1,y1,x2,y2=map(int,input().split())
a=x2-x1
b=y2-y1
x3=x2+b
y3=y2-a
x4=x3-a
y4=y3-b
print(x3,y3,x4,y4)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
x3, y3 = x2 + (y1 - y2), y2 - (x1 - x2)
x4, y4 = x3 + (y2 - y3), y3 - (x2 - x3)
print(x3, y3, x4, y4)
Buggy code:
x1,y1,x2,y2=map(int,input().split())
print((x2-(y2-y1)),(y2-(x1-x2)),(x1-(y2-y1)),(x1-(x1-x2)))


Fixed code:
x1, y1, x2, y2 = map(int, input().split())
print(x2 + y1 - y2, y2 + x2 - x1, x1 + y1 - y2, y1 + x2 - x1)
Buggy code:
l = map(int, input().split())
a=list(l)
x1=a[0]
y1=a[1]
x2=a[2]
y2=a[3]
x=x2-x1
y=y2-y1
x3=x2-y
y3=y2+x
x4=x1-y
y4=y1+x
c=[x3, y3, x4, y4]
print(c)

Fixed code:
l = map(int, input().split())
a=list(l)
x1=a[0]
y1=a[1]
x2=a[2]
y2=a[3]
x=x2-x1
y=y2-y1
x3=x2-y
y3=y2+x
x4=x1-y
y4=y1+x
c=[x3, y3, x4, y4]
print(c[0], c[1], c[2], c[3])
Buggy code:
x1,y1,x2,y2=list(map(int,input().split()))

if x2>x1 and y2>y1:
  x3=x2-abs(y2-y1);y3=y2+abs(x2-x1);x4=x3-abs(y3-y2);y4=y3-abs(x3-x2)

elif x2<x1 and y2>y1:
  x3=x2-abs(y2-y1);y3=y2-abs(x2-x1);x4=x3+abs(y3-y2);y4=y3-abs(x3-x2)

elif x2<x1 and y2<y1:
  x3=x2+abs(y2-y1);y3=y2-abs(x2-x1);x4=x3+abs(y3-y2);y4=y3+abs(x3-x2)

elif x2>x1 and y2<y1:
  x3=x2+abs(y2-y1);y3=y2+abs(x2-x1);x4=x3-abs(y3-y2);y4=y3+abs(x3-x2)

  
print(x3,y3,x4,y4)


Fixed code:
x1,y1,x2,y2=list(map(int,input().split()))

if x2>=x1 and y2>=y1:
  x3=x2-abs(y2-y1);y3=y2+abs(x2-x1);x4=x3-abs(y3-y2);y4=y3-abs(x3-x2)

elif x2<=x1 and y2>=y1:
  x3=x2-abs(y2-y1);y3=y2-abs(x2-x1);x4=x3+abs(y3-y2);y4=y3-abs(x3-x2)

elif x2<=x1 and y2<=y1:
  x3=x2+abs(y2-y1);y3=y2-abs(x2-x1);x4=x3+abs(y3-y2);y4=y3+abs(x3-x2)

elif x2>=x1 and y2<=y1:
  x3=x2+abs(y2-y1);y3=y2+abs(x2-x1);x4=x3-abs(y3-y2);y4=y3+abs(x3-x2)

  
print(x3,y3,x4,y4)
Buggy code:
import sys

def main():
  input = sys.stdin.readline
  x1, y1, x2, y2 = map(int, input().split())

  x4 = -(y2 - y1) + x1
  y4 = (x2 - x1) + y1
  x3 = x2 + x4 - x1
  y3 = y2 + y4 - y1
  print('{} {} {} {}'.format(x3, y3, x4, y4)


if __name__ == '__main__':
  main()

Fixed code:
import sys

def main():
  input = sys.stdin.readline
  x1, y1, x2, y2 = map(int, input().split())

  x4 = -(y2 - y1) + x1
  y4 = (x2 - x1) + y1
  x3 = x2 + x4 - x1
  y3 = y2 + y4 - y1
  print('{} {} {} {}'.format(x3, y3, x4, y4))


if __name__ == '__main__':
  main()
Buggy code:
from sys import stdin
x1,y1,x2,y2=[int(x) for x in stdin.readline().rstrip().split()]
x3=x2-abs(y1-y2)
y3=abs(x1-x2)+y2
x4=x1-abs(y1-y2)
y4=abs(x1-x2)+y1
print(x3,y3,x4,y4)

Fixed code:
from sys import stdin
x1,y1,x2,y2=[int(x) for x in stdin.readline().rstrip().split()]
x3=x2-(y2-y1)
y3=y2+(x2-x1)
x4=x1-(y2-y1)
y4=y1+(x2-x1)
print(x3,y3,x4,y4)
Buggy code:
x1,y1,x2,y2 = (int(i) for i in input().split())
if (x2-x1) >= 0 and (y2-y1) >=0 :
    x3 = x2 - abs((y2 - y1))
    y3 = y2 + abs((x2 - x1))
    x4 = x3 - abs((y3 - y2))
    y4 = y3 - abs((x3 - x2))
    print(x3,y3,x4,y4)

elif (x2-x1) < 0 and (y2-y1) >=0 :
    x3 = x2 - abs((y2 - y1))
    y3 = y2 - abs((x2 - x1))
    x4 = x3 + abs((y3 - y2))
    y4 = y3 + abs((x3 - x2))
    print(x3,y3,x4,y4)

elif (x2-x1) < 0 and (y2-y1) < 0 :
    x3 = x2 + abs((y2 - y1))
    y3 = y2 - abs((x2 - x1))
    x4 = x3 - abs((y3 - y2))
    y4 = y3 - abs((x3 - x2))
    print(x3,y3,x4,y4)

else:
    x3 = x2 + abs((y2 - y1))
    y3 = y2 + abs((x2 - x1))
    x4 = x3 - abs((y3 - y2))
    y4 = y3 + abs((x3 - x2))
    print(x3,y3,x4,y4)

Fixed code:
x1,y1,x2,y2 = (int(i) for i in input().split())
if (x2-x1) > 0 and (y2-y1) >=0 :
    x3 = x2 - abs((y2 - y1))
    y3 = y2 + abs((x2 - x1))
    x4 = x3 - abs((y3 - y2))
    y4 = y3 - abs((x3 - x2))
    print(x3,y3,x4,y4)


elif (x2-x1) <= 0 and (y2-y1) >=0 :
    x3 = x2 - abs((y2 - y1))
    y3 = y2 - abs((x2 - x1))
    x4 = x3 + abs((y3 - y2))
    y4 = y3 - abs((x3 - x2))
    print(x3,y3,x4,y4)

elif (x2-x1) <= 0 and (y2-y1) < 0 :
    x3 = x2 + abs((y2 - y1))
    y3 = y2 - abs((x2 - x1))
    x4 = x3 + abs((y3 - y2))
    y4 = y3 + abs((x3 - x2))
    print(x3,y3,x4,y4)


else:
    x3 = x2 + abs((y2 - y1))
    y3 = y2 + abs((x2 - x1))
    x4 = x3 - abs((y3 - y2))
    y4 = y3 + abs((x3 - x2))
    print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int,input().split())
deltax = x2 - x1
deltay = y2 - y1
x3 = x2 - deltay
y3 = y2 + deltax
x4 = x1 - deltay
y4 = y1 + deltax
print(x3, y3, x2, y2)

Fixed code:
x1,y1,x2,y2=map(int,input().split())
x3=x2+y1-y2
y3=y2-x1+x2
x4=x1+y1-y2
y4=y1-x1+x2
print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
print(x2 - dy, y2 + dx, x1 - dy, x2 + dx)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
print(x2 - dy, y2 + dx, x1 - dy, y1 + dx)
Buggy code:
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2-(x2-x1)
x4=x3-(y3-y2)
y4=y3-(x3-x2)
lst=[x3,y3,x4,y4]
print(*lst)

Fixed code:
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2+(x2-x1)
x4=x1+(y1-y2)
y4=y1-(x1-x2)
lst=[x3,y3,x4,y4]
print(*lst)
Buggy code:
x1,y1,x2,y2 = map(int,input())

x = x2-x1
y = y2-y1

x3 = x2 - y
y3 = y2 + x
x4 = x3 - x
y4 = y3 - y

print(x3,y3,x4,y4)




Fixed code:
x1,y1,x2,y2 = map(int,input().split())

x = x2-x1
y = y2-y1

x3 = x2 - y
y3 = y2 + x
x4 = x3 - x
y4 = y3 - y

print(x3,y3,x4,y4)
Buggy code:
#ABC108B
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1

x3 = x2 - dy
y3 = y2 + dx
 
x4 = x3 - dx
y4 = y3 - dy

Fixed code:
#ABC108B
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1

x3 = x2 - dy
y3 = y2 + dx
 
x4 = x3 - dx
y4 = y3 - dy

print(x3, y3, x4, y4)
Buggy code:
x1,x2,y1,y2=map(int,input().split())
x3=x2+y1-y2
y3=-x1+x2+y2
x4=x1-y2+y1
y4=y1-x1+x2

print(x3,y3,x4,y4)


Fixed code:
x1,y1,x2,y2 = map(int,input().split())
xa = x2-x1
ya = y2-y1
x3 = x2-ya
x4 = x1-ya
y3 = y2+xa
y4 = y1+xa
print(x3,y3,x4,y4)
Buggy code:
x1,y1,x2,y2=map(int,input().split())
dy = y2-y1
dx = x2-x1

print(x2+dy, y2+dx, x1-dy, y1-dx)

Fixed code:
x1,y1,x2,y2=map(int,input().split())
dy = y2-y1
dx = x2-x1

print(x2-dy, y2+dx, x1-dy, y1+dx)
Buggy code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

x1, y1, x2, y2 = rm()
c1, c2 = x1+y1*1j, x2+y2*1j
c3, c4 = -1j*(c2-c1), 1j*(c1-c2)
print(int(c3.real), int(c3.imag), int(c4.real), int(c4.imag))




Fixed code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

x1, y1, x2, y2 = rm()
c1, c2 = x1+y1*1j, x2+y2*1j
c3, c4 = -1j*(c1-c2) + c2, 1j*(c2-c1) + c1
print(int(c3.real), int(c3.imag), int(c4.real), int(c4.imag))
Buggy code:
x1,y1,x2,y2=list(map(int,input().split()))
dx=x2-x1
dy=y2-y1
print((x2-dy,y2+dx,x1-dy,y1+dx))


Fixed code:
x1,y1,x2,y2 = map(int,input().split())
dx = x2 - x1
dy = y2 - y1
print(x2-dy,y2+dx,x2-dy-dx,y2+dx-dy)
Buggy code:
l = input().split(" ")
p = [int(l[0]),int(l[1])]
q = [int(l[2]),int(l[3])]
r = [0,0]
s = [0,0]

if p[0]==q[0]:
    m = q[1]-p[1]
    r[0]=q[0]-m
    r[1]=q[1]
    s[0]=p[0]-m
    s[1]=p[1]
else:
    m = q[0]-p[0]
    r[0] = q[0]
    r[1] = q[1]+m
    s[0] = p[0]
    s[1] = p[1]+m
print(str(r[0])+" "+str(r[1])+" "+str(s[0])+" "+str(s[1]))

Fixed code:
l = input().split(" ")
p = [int(l[0]),int(l[1])]
q = [int(l[2]),int(l[3])]
r = [0,0]
s = [0,0]
if p[0]==q[0]:
    m = q[1]-p[1]
    r[0] = q[0]-m
    r[1] = q[1]
    s[0] = p[0]-m
    s[1] = p[1]
else:
    v = [q[1]-p[1],q[0]-p[0]]
    r[0]= q[0]-v[0]
    r[1]=q[1]+v[1]
    s[0]=p[0]-v[0]
    s[1]=p[1]+v[1]
print(str(r[0])+" "+str(r[1])+" "+str(s[0])+" "+str(s[1]))
Buggy code:
x_1,y_1,x_2,y_2=tuple(map(int,input().split()))

be=[x_2-x_1,y_2-y_1]
za3=[x_2+(-1)*be[1],y_2+be[0]]
za4=[x_1+(-1)*be[1],y_1+be[0]]

print(za3[0],za3[1],za4[0],za4[

Fixed code:
x_1,y_1,x_2,y_2=tuple(map(int,input().split()))

be=[x_2-x_1,y_2-y_1]
za3=[x_2+(-1)*be[1],y_2+be[0]]
za4=[x_1+(-1)*be[1],y_1+be[0]]

print(za3[0],za3[1],za4[0],za4[1])
Buggy code:
a,b,c,d=map(int,input().split())
y,x=c-a,d-b
print("{} {} {} {}".format(c+x,d+y,a-x,b-y))

Fixed code:
a,b,c,d=map(int,input().split())
y,x=c-a,d-b
print("{} {} {} {}".format(c-x,d+y,a-x,b+y))
Buggy code:
s=list(
  map(
    int, input().split())
  )
x1=s[0]
y1=s[1]
x2=s[2]
y2=s[3]
x3=x2+y1-y2
y3=y2+x1-x2
x4=x1+y1-y2
y4=y1+x1-x2
print(x3,y3,x4,y4)

Fixed code:
s=list(
  map(
    int, input().split())
  )
x1=s[0]
y1=s[1]
x2=s[2]
y2=s[3]
x3=x2+y1-y2
y3=y2-x1+x2
x4=x1+y1-y2
y4=y1-x1+x2
print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int, input().split())

y3 = y2 + x2- x1
y4 = x2 - x1 + y1
x3 = y1 - y2 + x2
x4 = y1 - y2 + x1

print(x3 y3 x4 y4)

Fixed code:
x1,y1,x2,y2 = map(int,input().split())

dx = x2 - x1
dy = y2 - y1
x3 = x2 - dy
y3 = y2 + dx
x4 = x1 - dy
y4 = y1 + dx


print(x3,y3,x4,y4)
Buggy code:
x1, y1, x2, y2 = map(int,input().split())
dx = x2-x1
dy = y2-y1
print(x2-dy,y2+dx,x2-dy+dx,y2+dx-dy)

Fixed code:
x1, y1, x2, y2 = map(int,input().split())
dx = x2-x1
dy = y2-y1
print(x2-dy,y2+dx,x2-dy-dx,y2+dx-dy)
Buggy code:
x1, y1, x2, y2 = map(int, input().split())
import math
x = x2 - x1
y = y2 - y1
theta3 = math.pi/4
x3 = int(math.sqrt(2) * (x*math.cos(theta3) - y*math.sin(theta3)))
y3 = int(math.sqrt(2) * (x*math.sin(theta3) + y*math.cos(theta3)))
theta4 = math.pi/2
x4 = int(x*math.cos(theta4) - y*math.sin(theta4))
y4 = int(x*math.sin(theta4) + y*math.cos(theta4))

print(x3+x1,y3+y1,x4+x1,y4+y1)

Fixed code:
x1, y1, x2, y2 = map(int, input().split())
import math
x = x2 - x1
y = y2 - y1
theta3 = math.pi/4
x3 = round(math.sqrt(2) * (x*math.cos(theta3) - y*math.sin(theta3)))
y3 = round(math.sqrt(2) * (x*math.sin(theta3) + y*math.cos(theta3)))
theta4 = math.pi/2
x4 = round(x*math.cos(theta4) - y*math.sin(theta4))
y4 = round(x*math.sin(theta4) + y*math.cos(theta4))

print(x3+x1,y3+y1,x4+x1,y4+y1)
Buggy code:
from sys import stdin
x1, y1, x2, y2 = [int(x) for x in stdin.readline.rstrip().split()]
print(x2-(y2-y1), y2+(x2-x1), x1-(y2-y1), y1+(x2-x1))

Fixed code:
from sys import stdin
x1, y1, x2, y2 = [int(x) for x in stdin.readline().rstrip().split()]
print(x2-(y2-y1), y2+(x2-x1), x1-(y2-y1), y1+(x2-x1))
Buggy code:
x1, y1, x2, y2 = map(int, input().split())

x = x2 - x1
y = y2 - y1
print(y2 - y, y2 + x, x1 - y, y1 + x)


Fixed code:
x1, y1, x2, y2 = map(int, input().split())

x = x2 - x1
y = y2 - y1
print(x2 - y, y2 + x, x1 - y, y1 + x)
Buggy code:
x1,y1,x2,y2=map(int,input().split())
print(x2+y2-y1,y2+x2-x1,x1+y2-y1,y1+x2-x1)

Fixed code:
x1,y1,x2,y2=map(int,input().split(' '))
print(x2-(y2-y1),y2+(x2-x1),x1-(y2-y1),y1+(x2-x1))
Buggy code:
x1,y1,x2,y2=map(int,input().split())
dx=x1-x2
dy=y1-y2

x3=x2+dy
y3=y2-dx

x4=x1+dy
y4=y1-dx
ans=[x3,y3,x4,y4]
print("".join(list(map(str,ans)))

Fixed code:
x1,y1,x2,y2=map(int,input().split())
dx=x1-x2
dy=y1-y2

x3=x2+dy
y3=y2-dx

x4=x1+dy
y4=y1-dx
ans=[x3,y3,x4,y4]
print(" ".join(list(map(str,ans))))