Problem:
 Score : 200 points    Problem Statement There is a square in the xy -plane. The coordinates of its four vertices are (x_1,y_1),(x_2,y_2),(x_3,y_3) and (x_4,y_4) in counter-clockwise order.
(Assume that the positive x -axis points right, and the positive y -axis points up.)  Takahashi remembers (x_1,y_1) and (x_2,y_2) , but he has forgot (x_3,y_3) and (x_4,y_4) .  Given x_1,x_2,y_1,y_2 , restore x_3,y_3,x_4,y_4 . It can be shown that x_3,y_3,x_4 and y_4 uniquely exist and have integer values.      Constraints  |x_1|,|y_1|,|x_2|,|y_2| \leq 100  (x_1,y_1) ≠ (x_2,y_2)  All values in input are integers.         Input Input is given from Standard Input in the following format:  x_1  y_1  x_2  y_2       Output Print x_3,y_3,x_4 and y_4 as integers, in this order.        Sample Input 1 0 0 0 1      Sample Output 1 -1 1 -1 0  (0,0),(0,1),(-1,1),(-1,0) is the four vertices of a square in counter-clockwise order.
Note that (x_3,y_3)=(1,1),(x_4,y_4)=(1,0) is not accepted, as the vertices are in clockwise order.       Sample Input 2 2 3 6 6      Sample Output 2 3 10 -1 7       Sample Input 3 31 -41 -59 26      Sample Output 3 -126 -64 -36 -131

Solution (Python):

import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
PI = math.pi

x1, y1, x2, y2 = ri_()
print(x2 - (y2 - y1), y2 + (x2 - x1), x1 - (y2 - y1), y1 + (x2 - x1))

Solution (Python):
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)

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())
print(x2-(y2-y1),y2+(x2-x1),x1-(y2-y1),y1+(x2-x1))

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

sa_x = x2 - x1
sa_y = y2 - y1

print(x2 - sa_y, y2 + sa_x, x1 - sa_y, y1 + sa_x)

Solution (Python):
a,b,c,d = map(int,input().split())
e = c - d + b
f = d + c - a
g = e - c + a
h = f - d + b
print(e,f,g,h)

Solution (Python):
Ax, Ay, Bx, By = map(int, input().split())
x = Ax - Bx
y = Ay - By

print(Bx + y, By - x, Ax + y, Ay - x)

Solution (Python):
x,y,z,w = map(int,input().split())
X,Y = (z-x),(w-y)
a,b = (z - Y),(w + X)
c,d = (a - X),(b - Y)
print(a,b,c,d)

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

dx, dy = x2 - x1, y2 - y1
dx, dy = -dy, dx

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

x4, y4 = x3 + dx, y3 + dy

print(x3, y3, x4, y4)

Solution (Python):
a, b, c, d = map(int, input().split())
print(c-d+b, d+c-a, a-d+b, b+c-a)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
l = y1 - y2
m = x1 - x2
print("{} {} {} {}".format(x2 + l, y2 - m, x1 + l, y1 - m))

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

Solution (Python):
a,b,c,d=map(int,input().split())
e=(d-b)
f=(c-a)
print(c-e,d+f,a-e,b+f)

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

x = x2 - x1 
y = y2 - y1

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

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

xl = x2-x1
yl = y2-y1

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

print(x3, y3, x4, y4)

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

Solution (Python):
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
    w = y2 - y1
    print(x2-w,y2+v,x1-w,y1+v)

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
print(str(x2-(y2-y1)) + " " + str(y2-(x1-x2)) + " " + str(x1-(y2-y1)) + " " + str(y1-(x1-x2)))

Solution (Python):
x1, y1, x2, y2 = list(map(int, input().split()))
dx = x2 - x1
dy = y2 - y1
print(x2-dy, y2+dx, x1-dy, y1+dx)

Solution (Python):
x_1, y_1, x_2, y_2 = map(int, input().split())

l = x_2 - x_1
m = y_2 - y_1

print(x_2-m, y_2+l, x_1-m, y_1+l)

Solution (Python):
import numpy as np
a,b,c,d = map(int,input().split())
X1 = np.array([a,b])
X2 = np.array([c,d])
x = (X2-X1)
x[0],x[1] = -x[1],x[0]
print((X2+x)[0],(X2+x)[1],(X1+x)[0],(X1+x)[1])

Solution (Python):
x1,y1,x2,y2=list(map(int,input().split()))
x=y2-y1
y=x2-x1  
print(x2-x,y2+y,x1-x,y1+y)

Solution (Python):
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)

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
vx = x2-x1
vy = y2-y1
print(x2-vy,y2+vx,x2-vy-vx,y2+vx-vy)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
X=x1-x2
Y=y1-y2
x3,y3=x2+Y,y2-X
x4,y4=x3+X,y3+Y
print(x3,y3,x4,y4)

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

Solution (Python):


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)

Solution (Python):
x1, y1, x2, y2 = map(int, input().strip().split())

v1x, v1y = x2 - x1, y2 - y1
v2x, v2y = -v1y, v1x

x3, y3 = x2 + v2x, y2 + v2y
x4, y4 = x3 - v1x, y3 - v1y

print(x3, y3, x4, y4)

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

dx = x2 - x1
dy = y2 - y1

nx1 = -dy
ny1 = dx
nx2 = -ny1
ny2 = nx1

print(x2+nx1,y2+ny1,x2+nx1+nx2,y2+ny1+ny2)

Solution (Python):


x1, y1, x2, y2 = map(int, input().split())
if x1 <= x2 and y1 <= y2:
    d4 = x2-x1
    d3 = y2-y1
    print(x2-d3, y2+d4, x1-d3, y1+d4)
elif x1 > x2 and y1 <= y2:
    d4 = y2-y1
    d3 = x1-x2
    print(x2-d4, y2-d3, x1-d4, y1-d3)
elif x1 > x2 and y1 > y2:
    d4 = x1-x2
    d3 = y1-y2
    print(x2+d3, y2-d4, x1+d3, y1-d4)
elif x1 <= x2 and y1  > y2:
    d4 = y1-y2
    d3 = x2-x1
    print(x2+d4, y2+d3, x1+d4, y1+d3)

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
if x1 == x2:
    print(x2+(y1-y2), y2, x2+(y1-y2), y1)
elif y1 == y2:
    print(x2, y2+(x2-x1), x1, y2+(x2-x1))
else:
    print(x2-(y2-y1), y2+(x2-x1), x1-(y2-y1), y1+(x2-x1))

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)

def main():
    a,b,c,d = map(int,input().split())
    dx = c - a
    dy = d - b
    print(c - dy,d + dx,a - dy,b + dx)
if __name__ == '__main__':
    main()

Solution (Python):
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)

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

dify=y2-y1
difx=x2-x1

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

print("{0} {1} {2} {3}".format(x3,y3,x4,y4))

Solution (Python):

x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
print(x2 - dy, y2 + dx, x1 - dy, y1 + dx)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
x=abs(x2-x1)
y=abs(y2-y1)
if x2>x1:
  if y2>y1:
    print(x2-y,y2+x,x1-y,y1+x)
  else:
    print(x2+y,y2+x,x1+y,y1+x)
else:
  if y2>y1:
    print(x2-y,y2-x,x1-y,y1-x)
  else:
    print(x2+y,y2-x,x1+y,y1-x)

Solution (Python):
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)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
from copy import deepcopy
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7

a,b,c,d=MI()
e=b+c-d
f=-a+c+d
g=a+b-d
h=b-a+c
print(e,end=" ")
print(f,end=" ")
print(g,end=" ")
print(h,end=" ")

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
print(x2+(y1-y2), y2+(x2-x1), x1+(y1-y2), y1+(x2-x1))

Solution (Python):
p,q,r,s=map(int,input().split())
print(r-(s-q),s+(r-p),r-(s-q)-(r-p),s+(r-p)-(s-q))

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

Solution (Python):
X,Y,Z,W=map(int,input().split())

a=Z-X
b=W-Y
print(Z-b,W+a,X-b,Y+a)

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

Solution (Python):
xy = list(map(int, input().split()))
xy1 = xy[0:2]
xy2 = xy[2:4]

d1 = xy2[0] - xy1[0]
d2 = xy2[1] - xy1[1]

xy3 = [xy2[0] - d2, xy2[1] + d1]
xy4 = [xy3[0] - d1, xy3[1] - d2]

print(*(xy3 + xy4))

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    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)
resolve()

Solution (Python):

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

od = [x1+y1-y2, y1-x1+x2]
oc = [x2-y2+y1, -x1+x2+y2]

od = map(str, list(od))
oc = map(str, list(oc))

print(' '.join(list(oc)) +' ' + ' '.join(list(od)))

Solution (Python):


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)

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

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

x_ = x2-x1
y_ = y2-y1

x_l = abs(x_)
y_l = abs(y_)

if x_ > 0 and y_ >= 0:
    x3 = x2 - y_l
    y3 = y2 + x_l
    x4 = x3 - x_l
    y4 = y3 - y_l

elif x_ < 0 and y_ <= 0:
    x3 = x2 + y_l
    y3 = y2 - x_l
    x4 = x3 + x_l
    y4 = y3 + y_l

elif x_ <= 0 and y_ > 0:
    x3 = x2 - y_l
    y3 = y2 - x_l
    x4 = x3 + x_l
    y4 = y3 - y_l

elif x_ >= 0 and y_ < 0:
    x3 = x2 + y_l
    y3 = y2 + x_l
    x4 = x3 - x_l
    y4 = y3 + y_l


print(int(x3), int(y3), int(x4), int(y4))

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
print(x2+y1-y2, y2+x2-x1, x1+y1-y2, y1+x2-x1)

Solution (Python):
li = list(map(int,input().split()))
xy1,xy2 = (li[0],li[1]),(li[2],li[3])
div=(xy2[0]-xy1[0],xy2[1]-xy1[1])
print(xy2[0]-div[1],xy2[1]+div[0],xy1[0]-div[1],xy1[1]+div[0],sep=" ")

Solution (Python):

import sys
try:
    from typing import List
except ImportError:
    pass


def solve(x: "List[int]", y: "List[int]"):
    x1, x2 = x
    y1, y2 = y
    x3 = x2 - (y2 - y1)
    y3 = y2 + (x2 - x1)
    x4 = x3 - (y3 - y2)
    y4 = y3 + (x3 - x2)
    print(x3, y3, x4, y4)


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    x = [int()] * (2)  
    y = [int()] * (2)  
    for i in range(2):
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
    solve(x, y)


if __name__ == '__main__':
    main()

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

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

print(x3, y3, x4, y4)

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


x3 = x2 + (y1-y2)
y3 = y2 + (x2-x1)


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

print(x3,y3,x4,y4)

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
print(x2+y1-y2,y2-x1+x2,x1+y1-y2,y2-x1+x2+y1-y2)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
print(x2-y2+y1,y2+x2-x1,x1-y2+y1,y1+x2-x1)

Solution (Python):
import numpy as np
import sys

input = sys.stdin.readline

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

yl = (y2 -y1)
xl = (x2 -x1)

print(x2-yl,y2+xl,x1-yl,y1+xl)

Solution (Python):
a,b,c,d=map(int,input().split());print(c-d+b,d+c-a,a-d+b,b+c-a)

Solution (Python):
A,B,C,D=map(int,input().split());print(C-D+B,D+C-A,A-D+B,B+C-A)

Solution (Python):
A,B,C,D = map(int, input().split());print(C-D+B,D+C-A,A-D+B,B+C-A)

Solution (Python):
A,B,C,D = map(int, input().split())
print(C-D+B,D+C-A,A-D+B,B+C-A)

Solution (Python):
A, B, C, D = map(int, input().split())
print(C-D+B,D+C-A,A-D+B,B+C-A)

Solution (Python):
A, B, C, D = map(int, input().split())
dx,dy = C-A,D-B
print(C-dy,D+dx,A-dy,B+dx)

Solution (Python):
A, B, C, D = map(int, input().split())

def solve(A,B,C,D):
    dx,dy = C-A,D-B
    ans = [C-dy,D+dx,A-dy,B+dx]
    return ans
print(*solve(A,B,C,D),sep=' ')

Solution (Python):
A, B, C, D = map(int, input().split())

def solve(A,B,C,D):
    dx,dy = C-A,D-B
    x,y = C-dy,D+dx
    ans = [x,y]
    x,y = x-dx,y-dy
    ans += [x,y]
    return ans
print(*solve(A,B,C,D),sep=' ')

Solution (Python):
A, B, C, D = map(int, input().split())

def solve(A,B,C,D):
    dx,dy = C-A,D-B
    x,y = C-dy,D+dx
    ans = [x,y]
    x,y = x-dx,y-dy
    ans.append(x)
    ans.append(y)
    return ans
print(*solve(A,B,C,D),sep=' ')

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
 
dx = x2-x1
dy = y2-y1
 
print(x2-dy,y2+dx,x1-dy,y1+dx)

Solution (Python):
a, b, c, d = map(int, input().split())

dx = c - a
dy = d - b

print(c-dy, d+dx, a-dy, b+dx)

Solution (Python):
xy = list(map(int, input().split()))


xy1dash = [-1 * xy[0], -1 * xy[1]]

xy2dash = [xy[2] + xy1dash[0], xy[3] + xy1dash[1]]


xy4dash = [-1 * xy2dash[1], xy2dash[0]]

xy4 = [xy4dash[0] - xy1dash[0], xy4dash[1] - xy1dash[1]]

xy3 = [xy4[0] + xy[2] - xy[0], xy4[1] + xy[3] - xy[1]]

print(xy3[0], xy3[1], xy4[0], xy4[1])

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

print(str(x3) + " " + str(y3) + " " + str(x4) + " " + str(y4))

Solution (Python):
a, b, c, d = map(int, input().split())
x, y = a-c, b-d
print(c+y, d-x, a+y, b-x)

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

Solution (Python):
x_1, y_1, x_2, y_2 = map(int, input().split())
d_x = x_2-x_1
d_y = y_2-y_1
print(x_2-d_y, y_2+d_x, x_1-d_y, y_1+d_x)

Solution (Python):
import sys
readline = sys.stdin.readline

def main():
    x1, y1, x2, y2 = map(int, readline().rstrip().split())
    dx = x2 - x1
    dy = y2 - y1
    x3 = x2 - dy
    y3 = y2 + dx
    x4 = x1 - dy
    y4 = y1 + dx
    print(x3, y3, x4, y4)


if __name__ == '__main__':
    main()

Solution (Python):
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)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
r=x2-x1
u=y2-y1
x3=x2-u
y3=y2+r
x4=x3-r
y4=y3-u
print("{} {} {} {}".format(x3,y3,x4,y4))

Solution (Python):
import math
x1, y1, x2, y2 = map(int, input().split())

dx = x2 - x1
dy = y2 - y1

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

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

Solution (Python):
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)

Solution (Python):
list1 = list(map(int,input().split()))
p1 = [list1[0],list1[1]]
p2 = [list1[2],list1[3]]
dv = [-(p2[1]-p1[1]),p2[0]-p1[0]]
p3 = [x1+x2 for x1,x2 in zip(p2,dv)]
p4 = [x1+x2 for x1,x2 in zip(p1,dv)]
[print(x,end=" ") for x in p3+p4]

Solution (Python):
def myAnswer(X1,Y1,X2,Y2):
   sub = X2 - X1
   length =  Y2 - Y1
   X3,Y3 = X1 - length,Y2
   X4,Y4 =  X1 - length,Y1
   X3 += sub
   Y3 += sub
   Y4 += sub
   print(X3,Y3,X4,Y4)

def modelAnswer():
   tmp=1
def main():
   X1,Y1,X2,Y2=map(int,input().split())
   myAnswer(X1,Y1,X2,Y2)


if __name__ == '__main__':
   main()

Solution (Python):
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)

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

Solution (Python):
x1,y1,x2,y2=map(int, input().split())
print(x2+y1-y2,y2-x1+x2,x1-x2+x2+y1-y2,y1-y2+y2-x1+x2)

Solution (Python):
import sys


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

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

main()

Solution (Python):
import math
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)

Solution (Python):
x_1, y_1, x_2, y_2 = map(int, input().split())
x = x_2 - x_1
y = y_2 - y_1
x_3 = x_2 - y
y_3 = y_2 + x
x_4 = x_1 - y
y_4 = y_1 + x
print("{} {} {} {}".format(x_3, y_3, x_4, y_4))

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

x3 = str(y1 - y2 + x2)
x4 = str(y1 - y2 + x1)
y3 = str(x2 - x1 + y2)
y4 = str(x2 - x1 + y1)

print(x3 + ' ' + y3 + ' ' + x4 + ' ' + y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
print(x2-(y2-y1), y2+(x2-x1), x1-(y2-y1), y1+(x2-x1))

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
v=[x2-x1,y2-y1]
print(x2-v[1],y2+v[0],x1-v[1],y1+v[0])

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

amountx = x2 - x1
amounty = y2 - y1

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

print(x3, y3, x4, y4)

Solution (Python):
a, b, c, d = map(int, input().split())

dx, dy = a-c, d-b

print(c-dy, d-dx, a-dy, b-dx)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
  x1, y1, x2, y2 = map(int, input().split())
  y = y2 - y1
  x = x2 - x1
  x3 = x2 - y
  y3 = y2 + x
  x4 = x1 - y
  y4 = y1 + x
  print(x3, y3, x4, y4)

if __name__ == '__main__':
  main()

Solution (Python):
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

print(x3, y3, x4, y4)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def main():
    x1, y1, x2, y2 = map(int, readline().split())
    A = complex(x1, y1)
    B = complex(x2, y2)
    routate = 1j
    C = (B-A) * routate + B
    D = (B-A) * routate + A
    print(int(C.real), int(C.imag), int(D.real), int(D.imag))
if __name__ == '__main__':
    main()

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
DP2 = lambda d1, d2: [[INIT_VAL]*d2 for _ in range(d1)]
DP3 = lambda d1, d2, d3: [[[INIT_VAL]*d3 for _ in range(d2)] for _ in range(d1)]

def main():
    x1, y1, x2, y2 = MII()
    a = x2 - x1
    b = y2 - y1
    x3 = x2 - b
    y3 = y2 + a
    x4 = x1 - b
    y4 = y1 + a
    print(x3, y3, x4, y4)
    
if __name__ == '__main__':
    main()

Solution (Python):

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

x3, y3 = x2 - y, y2 + x 
x4, y4 = x1 - y, y1 + x
print(x3, y3, x4, y4)

Solution (Python):
x1, y1, x2, y2=map(int, input().split())
s=x2 -x1
t=y2 -y1
d=s**2 +t**2

if s>=0 and t>=0:
    k=-t
    l=s
elif s<=0 and t<=0:
    k=-t
    l=s
elif s>=0 and t<=0:
    k=-t
    l=s
elif s<=0 and t>=0:
    k=-t
    l=s

x3=x2+k
y3=y2+l
x4=x3-s
y4=y3-t
print(x3, y3, x4, y4)

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007


def A():
    return


def B():
    x1, y1, x2, y2 = LI()
    a = x2 - x1
    b = y2 - y1
    print(x2 - b, y2 + a, x1 - b, y1 + a)
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    B()

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, y2+x2-x1, x1-y2+y1, y1+x2-x1)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, y2+x2-x1, x1-y2+y1,y1+x2-x1)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
dx=(x2-x1)
dy=(y2-y1)
print(x2-dy,y2+dx,x1-dy,y1+dx)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
v = [x2 - x1, y2 - y1]
w = [y1 - y2, x2 - x1]
print(x1 + v[0] + w[0], y1 + v[1] + w[1], x1 + w[0], y1 + w[1])

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

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

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
x = x1 - x2
y = y1 - y2
point3 = [x2 + y, y2 - x]
point4 = [x1 + y, y1 - x]
print(point3[0], point3[1], point4[0], point4[1])

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
x = x1 - x2
y = y1 - y2
point3 = [x2 + y, y2 - x]
point4 = [x1 + y, y1 - x]
print(*[point3[0], point3[1], point4[0], point4[1]], sep=' ')

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

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

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

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

Solution (Python):
import sys
from functools import reduce
from fractions import gcd

sys.setrecursionlimit(10 ** 6)


def input(): return sys.stdin.readline().rstrip()

x1, y1, x2, y2 = map(int, input().split())
dx, dy = y1 - y2, x2 - x1
print(x2 + dx, y2 + dy, x1 + dx, y1 + dy)

Solution (Python):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    dx, dy = x2 - x1, y2 - y1
    x3, y3, x4, y4 = x2 - dy, y2 + dx, x1 - dy, y1 + dx
    print('%d %d %d %d' % (x3, y3, x4, y4))


if __name__ == '__main__':
    main()

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
print('{} {} {} {}'.format(x2-dy, y2+dx, x1-dy, y1+dx))

Solution (Python):
def main(x1,y1,x2,y2):
    x,y = [x2-x1, y2-y1]
    p3 = [x2-y, y2+x]
    p4 = [x1-y, y1+x]
    print(p3[0],p3[1],p4[0],p4[1]) 

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

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,operator,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

x1,y1,x2,y2 = LI()
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)

Solution (Python):
x_1,y_1,x_2,y_2=map(int,input().split())
a=x_2-x_1
b=y_2-y_1
x_3=x_2-b
y_3=y_2+a
x_4=x_3-y_3+y_2
y_4=y_3+x_3-x_2
print(x_3,y_3,x_4,y_4)

Solution (Python):
icase=0
if icase==0:
    x1,y1,x2,y2=map(int,input().split())
    r=((x2-x1)**2+(y2-y1)**2)**0.5
    ix=(x2-x1)/r
    iy=(y2-y1)/r
    jx=-iy
    jy=ix
    x3=int(x2+r*jx)
    y3=int(y2+r*jy)
    x4=int(x3-r*ix)
    y4=int(y3-r*iy)
    print(x3,y3,x4,y4)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
d_x = x2 - x1
d_y = y2 - y1
x3 = x2 - (d_y)
y3 = y2 + (d_x)
x4 = x3 - d_x
y4 = y3 - d_y

print(x3, y3, x4, y4)

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

if x2 >= x1:
    if y2 >= y1:
        print(x2-y2+y1,y2+x2-x1,x1-y2+y1,y1+x2-x1)
    else:
        print(x2+y1-y2,y2+x2-x1,x1+y1-y2,y1+x2-x1)
else:
    if y2 >= y1:
        print(x2-y2+y1,y2-x1+x2,x1-y2+y1,y1-x1+x2)
    else:
        print(x2+y1-y2,y2-x1+x2,x1+y1-y2,y1-x1+x2)

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

side_x=x2-x1
side_y=y2-y1

pattern = [[side_x,side_y],[-side_y,side_x],[-side_x,-side_y],[side_y,side_x]]*2

i = pattern.index([side_x,side_y])
x3,y3 = x2+pattern[i+1][0],y2+pattern[i+1][1]
x4,y4 = x3+pattern[i+2][0],y3+pattern[i+2][1]
print(x3,y3,x4,y4)

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

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

Solution (Python):

x1, y1, x2, y2 = [int(s) for s in input().split()]
x3, y3 = x2 - (y2 - y1), y2 + (x2 - x1)
x4, y4 = x1 - (y2 - y1), y1 + (x2 - x1)
print(x3, y3, x4, y4)

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

base_y = y2-y1
base_x = x2-x1

y3 = y2 + base_x
x3 = x2 - base_y

y4 = y1 + base_x
x4 = x1 - base_y


print(x3,y3,x4,y4)

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

x3,y3 = x2-(y2-y1),y2+(x2-x1)
x4,y4 = x3-(y3-y2),y3+(x3-x2)

print(x3,y3,x4,y4)

Solution (Python):
a, b, c, d = map(int, input().split())
x = c - a
y = d - b

print('{} {} {} {}'.format(c - y, d + x, a - y, b + x))

Solution (Python):
def main():
    x1, y1, x2, y2 = map(int, input().split())
    x4 = x1 - (y2 - y1)
    y4 = y1 + x2 - x1
    x3 = x4 - (y1 - y4)
    y3 = y4 + x1 - x4
    print("{} {} {} {}".format(x3, y3, x4, y4))
main()

Solution (Python):


x1,y1,x2,y2 = map(int,input().split())
a = x2-x1
b = y2-y1
print(x2-b,y2+a,x1-b,y1+a)

Solution (Python):

import io

n1, m1, n2, m2 = map(int, input().split())

print(n2-m2+m1, m2+n2-n1, n1-m2+m1, m1+n2-n1)

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

a = x2 - x1
b = y2 - y1


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

Solution (Python):
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)

Solution (Python):
import sys

def main(lines):
  x1, y1, x2, y2 = map(int, lines[0].split())
  x3 = x2 + (y2 - y1) * -1
  y3 = y2 + (x2 - x1)
  x4 = x3 + (y3 - y2) * -1
  y4 = y3 + (x3 - x2)
  print(x3, y3, x4, y4)


if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)

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

Solution (Python):
x_1,y_1,x_2,y_2 = map(int,input().split())
print(y_1+x_2-y_2,-x_1+x_2+y_2,x_1+y_1-y_2,-x_1+y_1+x_2)

Solution (Python):
A,B,C,D=map(int,input().split());print(B+C-D,-A+C+D,A+B-D,-A+B+C)

Solution (Python):
x1, y1, x2, y2 = map(int,input().split())
print(*[x2+y1-y2, x2-x1+y2, x1+y1-y2, x2-x1+y1])

Solution (Python):












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)

Solution (Python):
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)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
print(x2-(y2-y1),y2-(x1-x2),x1-(y2-y1),y1-(x1-x2),end='')

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

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

print(x3,y3,x4,y4)

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

Solution (Python):
import sys
 
input = sys.stdin.readline
 
x1, y1, x2, y2 = map(int, input().split())

dx = x2 - x1
dy = y2 - y1

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

Solution (Python):
a1,b1,a2,b2=map(int,input().split())
c=a2-a1
d=b2-b1
e=-d
f=c
a3=a2+e
b3=b2+f
a4=a3-c
b4=b3-d
print(a3,b3,a4,b4)

Solution (Python):
X1, Y1, X2, Y2 = map(int, input().split())

X3 = X2 + (Y1 - Y2)
Y3 = Y2 - (X1 - X2)
X4 = X3 + (X1 - X2)
Y4 = Y3 + (Y1 - Y2)

print(X3, Y3, X4, Y4)

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

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

print(x3, y3, x4, y4)

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

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

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

Solution (Python):
x1,y1,x2,y2 = list(map(int,input().split()))
dx,dy = x2-x1,y2-y1
print(x2-dy,y2+dx,x1-dy,y1+dx)

Solution (Python):
x1, y1, x2, y2 = list(map(int, input().split()))

dx, dy = x2 - x1, y2 - y1

x3, y3 = x2 - dy, y2 + dx
x4, y4 = x1 - dy, y1 + dx
print(x3, y3, x4, y4)

Solution (Python):
def myAnswer(X1,Y1,X2,Y2):
   X = X2 - X1
   Y = Y2 - Y1
   print(X2 - Y,Y2 + X, X1 - Y, Y1 + X)

def modelAnswer():
   tmp=1
def main():
   X1,Y1,X2,Y2=map(int,input().split())
   myAnswer(X1,Y1,X2,Y2)


if __name__ == '__main__':
   main()

Solution (Python):
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)

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

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
import numpy as np

x1 = np.array([x1,y1])
x2 = np.array([x2,y2])
rot = np.array([[0,-1],[1,0]])
x3 = np.dot(rot,(x2-x1))+x2
x4 = np.dot(rot,(x3-x2))+x3
print(x3[0],x3[1],x4[0],x4[1])