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):
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(x3, y3, x4, y4)

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
x,y= x2-x1, 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):
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('{} {} {} {}'.format(x3, y3, x4, y4))

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

	print('{} {} {} {}'.format(x3,y3,x4,y4))		

resolve()

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

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

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-(y3-y2)
y4=y3+(x3-x2)
print(x3,y3,x4,y4)

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

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

print(x2-y2+y1, x2-x1+y2, 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-(y3-y2)
y4=y3+(x3-x2)


print(x3,y3,x4,y4)

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

Solution (Python):
import numpy as np
x1,y1,x2,y2 = map(int, input().split())
ori = np.array([x1,y1])
vec = np.array([x2-x1,y2-y1])
def rotation(pi,a,b):
    rot = np.matrix([[np.cos(pi),-np.sin(pi)],
                     [np.sin(pi),np.cos(pi)]])
    return np.dot(rot, [a,b])

p3 = np.sqrt(2)*(rotation(np.pi/4, vec[0], vec[1])) + ori
p4 = rotation(np.pi/2, vec[0], vec[1]) + ori

x3 = int(round(p3[0,0]))
y3 = int(round(p3[0,1]))
x4 = int(round(p4[0,0]))
y4 = int(round(p4[0,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 = map(int, input().split())
print(
    x2 + y1 - y2,
    y2 + x2 - x1,
    x1 + y1 - y2,
    y1 + x2 - x1
)

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):
x1,y1,x2,y2=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):
a, b, c, d = list(map(int, input().split()))
x = c-a
y = d-b
print(c-y, d+x, a-y, b+x)

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

x1, y1, x2, y2 = nl()

xd = x2 - x1
yd = y2 - y1
print(x2 - yd, y2 + xd, x2 - yd - xd, y2 + xd - yd)

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

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

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

vec = (x2 - x1, y2 - y1)

vec = (-vec[1], vec[0])
x3 = x2 + vec[0]
y3 = y2 + vec[1]

vec = (-vec[1], vec[0])
x4 = x3 + vec[0]
y4 = y3 + vec[1]

print(x3, y3, x4, y4)

Solution (Python):
x,y,X,Y=map(int,input().split())
print(X-Y+y)
print(Y-x+X)
print(x-Y+y)
print(y-x+X)

Solution (Python):
x1, y1, x2, y2 = (int(i) for i in input().split())
x4 = x1 - (y2 - y1)
y4 = y1 + (x2 - x1)
x3 = x4 - (y1 - y4)
y3 = y4 + (x1 - x4)
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 = x1 - dy, y1 + dx

print(x3, y3, x4, y4)

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

x_temp = x2 - x1
y_temp = y2 - y1

x3 = x2 - y_temp
y3 = y2 + x_temp

x4 = x3 - x_temp
y4 = y3 - y_temp

print(x3, y3, x4, y4)

Solution (Python):
def rot(v):
    v = [-v[1],v[0]]
    return v

S = list(map(int, input().split()))

u = [S[2]-S[0],S[3]-S[1]]
v = rot(u)
w = rot(v)

X3 = [S[2]+v[0],S[3]+v[1]]
X4 = [X3[0]+w[0],X3[1]+w[1]]

print(*(X3+X4))

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):
def abc():
    x1, y1, x2, y2 = map(int, input().split())
    dx = x2 - x1
    dy = y2 - y1
    x3 = x2 - dy
    y3 = y2 + dx

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

    print(x3, y3, x4, y4)


abc()

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

Solution (Python):

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


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


print(x3, y3, x4, y4)

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

vector = [-1 * (y2 - y1), x2 - x1]
x3 = x2 + vector[0]
y3 = y2 + vector[1]
x4 = x1 + vector[0]
y4 = y1 + vector[1]

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):
x1, y1, x2, y2 = map(int, input().split())

dx, dy = x2 - x1, y2- y1

for i in range(2):
    dx, dy = -dy, dx
    x2 += dx
    y2 += dy
    print(x2, y2, end=' ')

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

x3, y3 = x1 + dx - dy, y1 + dy + dx
x4, y4 = x1 - dy, y1 + dx

print(x3, y3, x4, y4)

Solution (Python):
import numpy as np
x1, y1, x2, y2 = map(int, input().split())
c1 = np.array([x1, y1])
c2 = np.array([x2, y2])
vec1 = c2 - c1
rot = np.array([[0, 1], [-1, 0]])
vec1 = np.dot(vec1, rot)
c3 = c2 + vec1
vec1 = np.dot(vec1, rot)
c4 = c3 + vec1
ans = c3.tolist() + c4.tolist()
ans = list(map(str, ans))
print(" ".join(ans))

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

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

Solution (Python):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

x1, y1, x2, y2 = list(map(int, sys.stdin.readline().split()))
x3 = x2 - (y2 - y1)
y3 = y2 - (x1 - x2)
x4 = x3 - (y3 - y2)
y4 = y3 - (x2 - x3)
print(x3, y3, x4, y4)

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

a=n[1]-n[3]+n[2]
b=n[2]-n[0]+n[3]
c=n[1]-n[3]+n[0]
d=n[2]-n[0]+n[1]


print(a,b,c,d)

Solution (Python):

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



dx, dy = x2-x1, y2-y1

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

print( "{} {} {} {}".format(x3,y3,x4,y4) )

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

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

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

print("{} {} {} {}".format(x3, y3, x4, y4))

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

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

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())
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)

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):
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())
print(x2+(y1-y2),y2+(x2-x1),x1+(y1-y2),y1+(x2-x1))

Solution (Python):
x1,y1,x2,y2 = list(map(int,input().split()))
 
a = x2-x1
b = y2-y1
y3 = y2 + a
x3 = x2 - b
y4 = y3 -b
x4 = x3 -a
 
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("{} {} {} {}".format(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().split())
  
dx, dy = x2-x1, y2-y1
x3, y3, x4, y4 = x2-dy, y2+dx, x1-dy, y1+dx

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 - (y2-y1)
y4 = y1 + (x2-x1)
print(x3, y3, x4, y4, sep=" ")

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

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

p =  [ls[2]-ls[0],ls[3]-ls[1]]

b = [-p[1],p[0]]
c = [-b[1],b[0]]

p3 = [ls[2]+b[0],ls[3]+b[1]]
p4 = [p3[0]+c[0],p3[1]+c[1]]
print(p3[0],p3[1],p4[0],p4[1])

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

Solution (Python):

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

Solution (Python):
x,y,X,Y=map(int,input().split())
print(X-Y+y,Y+X-x,x-Y+y,y+X-x)

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

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())
a,b = x2-x1,y2-y1
print(x2-b,y2+a,x1-b,y1+a)

Solution (Python):
p = list(map(int, input().split()))
s, d = list(map(lambda x, y: x + y * 1j, p[::2], p[1::2]))

ans = ""
for _ in range(2):
  v = d - s
  s = d
  d = s + v * 1j
  ans += " {:.0f} {:.0f}".format(d.real, d.imag)
print(ans[1:])

Solution (Python):
import numpy as np
p = list(map(int, input().split()))
s, d = list(map(lambda x, y: np.array([x, y]), p[::2], p[1::2]))

ans = ""
for _ in range(2):
  v = d - s
  s = d
  d = s + v.dot([[0,1], [-1,0]])
  ans += " " + " ".join(map(str, d))
print(ans[1:])

Solution (Python):
a,b,c,d=map(int,input().split())
l=[0]*4
l[0]=c+b-d
l[1]=d-(a-c)
l[2]=l[0]+a-c
l[3]=l[1]+(b-d) 
for i in range(3):
    print(l[i],end=' ')
print(l[3])

Solution (Python):
import numpy as np

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

r = np.array([[0, -1], [1, 0]])
p1 = np.array([[x1, y1]])
p2 = np.array([[x2, y2]])
vec = p2 - p1
p4 = r.dot(vec.T).flatten() + p1
p3 = p4 + vec

x3, y3 = p3.flatten()
x4, y4 = p4.flatten()

print(x3, y3, x4, y4)

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

for i in range(2):
  z.append(z[2*i+2] - (z[2*i+3] - z[2*i+1]))
  z.append(z[2*i+3] + (z[2*i+2] - z[2*i]))
  
print(str(z[4]) + " " + str(z[5]) + " " + str(z[6]) + " " + str(z[7]))

Solution (Python):
x_1, y_1, x_2, y_2 = [int(xy) for xy in input().split()]
dx = x_2 - x_1
dy = y_2 - y_1

x_3 = x_2 - dy
y_3 = y_2 + dx
x_4 = x_1 - dy
y_4 = y_1 + dx

print(str(x_3) + " " + str(y_3) + " " + str(x_4) + " " + str(y_4))

Solution (Python):
p = list(map(int, input().split()))
ps = list(zip(p[::2], p[1::2]))

ans = ""
for _ in range(2):
  v = list(map(lambda x, y: x - y, ps[1], ps[0]))
  v = [-v[1], v[0]]
  ps = [ps[1], list(map(lambda x, y: x + y, ps[1], v))]
  ans += " " + " ".join(map(str, ps[1]))

print(ans[0:])

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

d = (-d[1], d[0])
x3, y3 = x2 + d[0], y2 + d[1]

d = (-d[1], d[0])
x4, y4 = x3 + d[0], y3 + d[1]

print(x3, y3, x4, y4)

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    x1, y1, x2, y2 = f()
    
    x3 = x2 + (y1 - y2)
    y3 = y2 + (x2 -x1)
    

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


    print(x3, y3, x4, y4)


solve()

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

d = [x2-x1,y2-y1]

def rot90(x):
    return [-x[1], x[0]]
    
d23 = rot90(d)
d34 = rot90(d23)

x3 = x2+d23[0]
y3 = y2+d23[1]
x4 = x3+d34[0]
y4 = y3+d34[1]

print(x3,y3,x4,y4)

Solution (Python):

lst_1 = input().split()

x_1 = int(lst_1[0])
y_1 = int(lst_1[1])
x_2 = int(lst_1[2])
y_2 = int(lst_1[3])

x_3 = x_2 - (y_2 - y_1)
y_3 = y_2 + (x_2 - x_1)
x_4 = x_3 - (x_2 - x_1)
y_4 = y_3 - (y_2 - y_1)

print("{} {} {} {}".format(x_3, y_3, x_4, y_4))

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

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('{} {} {} {}'.format(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):
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)

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 = [ int(v) for v in input().split() ]

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

print(x3, y3, x4, y4)

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

x = abs(x1-x2)
y = abs(y1-y2)

if x1 >= x2 and y1 >= y2:
  x3 = x2 + y
  y3 = y2 - x
  x4 = x3 + x
  y4 = y3 + y
elif x1 <= x2 and y1 >= y2:
  x3 = x2 + y
  y3 = y2 + x
  x4 = x3 - x
  y4 = y3 + y
elif x1 <= x2 and y1 <= y2:
  x3 = x2 - y
  y3 = y2 + x
  x4 = x3 - x
  y4 = y3 - y
else:
  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())

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

print(x3, y3, x4, y4)

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

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())
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):
x1,y1,x2,y2 = map(int,input().split())
p = x2 - x1
q = y2 - y1
print(x2 - q, y2 + p, x1 - q, y1 + p)

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):
a,b,c,d=map(int,input().split())
print(b-d+c,end=" ")
print(c-a+d,end=" ")
print(b-d+a,end=" ")
print(c-a+b,end=" ")

Solution (Python):
x1,y1,x2,y2 = list(map(int,input().split()))
x3=y3=x4=y4=0
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())

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

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(str(x3) + " " + str(y3) + " " + str(x4) + " " + str(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().split())

dx = x2 - x1
dy = y2 - y1

x3 = x2 - dy
y3 = y2 + dx

x4 = x1 - dy
y4 = y1 + dx

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

Solution (Python):
x1,y1,x2,y2 = [ int(it) for it in input().split() ]

dx = x2-x1
dy = y2-y1

x,y=x2,y2
x,y=x-dy,y+dx
z,w=x-dx,y-dy
print (x,y,z,w)

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())
MoveX,MoveY = x2 - x1,y2 - y1
x3,y3 = x2 - MoveY,y2 + MoveX
x4,y4 = x3 - MoveX,y3 - MoveY
print('{} {} {} {}'.format(x3,y3,x4,y4))

Solution (Python):
x1, y1, x2, y2 = map(int, raw_input().split())
dx = x2-x1
dy = y2-y1
x3 = x2-dy
y3 = y2+dx
x4 = x3-dx
y4 = y3-dy
print str(x3)+' '+str(y3)+' '+str(x4)+' '+str(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 = map(int,input().split())
x,y = x2 - x1,y2 - y1
print(x2 - y,y2 + x,x1 - y,y1 + x)

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 solve(x: "List[int]", y: "List[int]"):
    dx = x[1] - x[0]
    dy = y[1] - y[0]

    x3 = x[1] - dy
    y3 = y[1] + dx
    x4 = x[0] - dy
    y4 = y[0] + dx

    print(x3,y3,x4,y4)
    return



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):
from sys import stdin
import numpy as np

A = np.array([int(x) for x in stdin.readline().rstrip().split()])
B = np.reshape(A, (2, 2))
vector = np.array(B[1] - B[0])
print(
    str((B[1] - np.array([vector[1], -vector[0]]))[0]) + ' ' + str((B[1] - np.array([vector[1], -vector[0]]))[1])
    + ' ' + str((B[0] - np.array([vector[1], -vector[0]]))[0]) + ' ' + str((B[0] - np.array([vector[1], -vector[0]]))[1])
)

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


x3, y3 = x2 - dy, y2 + dx
x4, y4 = x1 - dy, y1 + dx
x3, y3, x4, y4 = int(x3), int(y3), int(x4), int(y4)
print("{0} {1} {2} {3}".format( 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-(x2-x1)
y4 = y3 -(y2-y1)
print(x3,y3,x4,y4)

Solution (Python):
u,v,x,y = map(int,input().split())
[p,q] = [x-(y-v),y+(x-u)]
[r,s] = [p-(q-y),q+(p-x)]
print(p,q,r,s)

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

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
w=x2-x1
h=y2-y1
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())
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):

"""
B - Ruined Square
https://atcoder.jp/contests/abc108/tasks/abc108_b

"""
import sys


def solve(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    x3, y3 = x2 - dy, y2 + dx
    dx = x3 - x2
    dy = y3 - y2
    x4, y4 = x3 - dy, y3 + dx
    return (x3, y3, x4, y4)


def main(args):
    x1, y1, x2, y2 = map(int, input().split())
    ans = solve(x1, y1, x2, y2)
    print(*ans)


if __name__ == '__main__':
    main(sys.argv[1:])

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

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

def calc_x3_y3():
    if (x2 - x1) >= 0 and (y2 - y1) >= 0:
        return [x2 - abs(y2 - y1), y2 + abs(x2 - x1)]
    elif (x2 - x1) >= 0:
        return [x2 + abs(y2 - y1), y2 + abs(x2 - x1)]
    elif (x2 - x1) < 0 and (y2 - y1) >= 0:
        return [x2 - abs(y2 - y1), y2 - abs(x2 - x1)]
    else:
        return [x2 + abs(y2 - y1), y2 - abs(x2 - x1)]

def cakc_x4_y4():
    if (x2 - x1) >= 0 and (y2 - y1) >= 0:
        return  [x1 - abs(y2 - y1), y1 + abs(x2 - x1)]
    elif (x2 - x1) >= 0:
        return  [x1 + abs(y2 - y1), y1 + abs(x2 - x1)]
    elif (x2 - x1) < 0 and (y2 - y1) >= 0:
        return  [x1 - abs(y2 - y1), y1 - abs(x2 - x1)]
    else:
        return  [x1 + abs(y2 - y1), y1 - abs(x2 - x1)]

print(calc_x3_y3()[0], calc_x3_y3()[1],  cakc_x4_y4()[0],  cakc_x4_y4()[1])

Solution (Python):


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

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

x=c-a
y=d-b

e=c-y
f=d+x
g=e-x
h=f-y

print(str(e)+' '+str(f)+' '+str(g)+' '+str(h))

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):
import numpy as np

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

p1 = np.array([x1, y1])
p2 = np.array([x2, y2])

rotate = np.array([[0, 1], [-1, 0]])

p3 = p2 + np.dot((p2 - p1),rotate)
p4 = p3 + np.dot((p3 - p2),rotate)

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

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

sax = x2 -x1
say = y2- y1

x3 = x2 - say
x4 = x3 - sax
y3 = y2 + sax
y4 = y3 - say

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())
x3,y3=x2-(y2-y1),y2+(x2-x1)
x4,y4=x3-(x2-x1),y3-(y2-y1)
print(x3,y3,x4,y4)

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

y3=b+x
y3=str(y3)
print(x2+' '+y2+' '+x3+' '+y3)

Solution (Python):
x1, y1, x2, y2 = map(int, input().split())
if (y2-y1) >=0 and (x2-x1) >=0:
    x3 = x2 - abs(y2-y1)
    y3 = y2 + abs(x2-x1)
elif (y2-y1) >=0 and (x2-x1) <0:
    x3 = x2 - abs(y2-y1)
    y3 = y2 - abs(x2-x1)
elif (y2-y1) <0 and (x2-x1) >=0:
    x3 = x2 + abs(y2-y1)
    y3 = y2 + abs(x2-x1)
else:
    x3 = x2 + abs(y2-y1)
    y3 = y2 - abs(x2-x1)
x4 = x3 - (x2-x1)
y4 = y3 - (y2-y1)
print(x3, y3, x4, y4)

Solution (Python):
import numpy as np

x1, y1, x2, y2 = map(int, input().split())
A = np.array([[0, -1], [1, 0]])
x = np.array([[x2 - x1], [y2 - y1]])
tmp = np.dot(A, x) + np.array([[x1], [y1]])
x4, y4 = tmp[0][0], tmp[1][0]

center = np.array([(x2 + x4)/2, (y2 + y4)/2])
tmp = np.array([x1, y1]) + 2 * (center - np.array([x1, y1]))
x3, y3 = int(tmp[0]), int(tmp[1])

print(x3, y3, x4, y4)

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

vec_x = lst[2] - lst[0]
vec_y = lst[3] - lst[1]

x3 = lst[2] - vec_y
y3 = lst[3] + vec_x

x4 = x3 - vec_x
y4 = y3 - vec_y

print (x3, end =' ')
print (y3, end =' ')
print (x4, end =' ')
print (y4)

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

x_3 = x_2 + y_1 - y_2
y_3 = y_2 + x_2 - x_1
x_4 = x_3 + y_2 - y_3
y_4 = y_3 + x_3 - x_2

print(x_3,y_3,x_4,y_4)

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().split())
x4 = x1 - y2 + y1
x3 = x4 + x2 - x1
y4 = y1 + x2 - x1
y3 = y4 + y2 - y1
print(x3, y3, x4, y4)

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

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

if __name__=='__main__':
    main()

Solution (Python):
x1,x2,x3,x4 = map(int,input().split())

x5 = x2 - x4 + x3
x6 = x3 - x1 + x4
x7 = x2 - x4 + x1
x8 = x3 - x1 + x2

print(str(x5) + " " + str(x6) + " " + str(x7) + " "+ str(x8))

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

Solution (Python):

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(" ".join(map(str, [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(str(x3)+' '+str(y3)+' '+str(x4)+' '+str(y4))

Solution (Python):

from sys import stdin

x1,y1,x2,y2 = map(int,stdin.readline().rstrip().split())

def main():
    print("{} {} {} {}".format(x2 - y2 + y1, y2 + x2 - x1, x1 - y2 + y1, y1 + x2 - x1 ))
    
    
if __name__ == '__main__':
    main()

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

def vector(x1, y1, x2, y2):
    return x2 - (y2 - y1), y2 + (x2 - x1)

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

print(x3, y3, x4, y4)

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

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

x12 = x2 - x1
y12 = y2 - y1

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

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

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

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    x1, y1, x2, y2 = intin()

    xdiff = x2 - x1
    ydiff = y2 - y1

    x3 = x2 - ydiff
    y3 = y2 + xdiff
    x4 = x3 - xdiff
    y4 = y3 - ydiff

    print(x3, y3, x4, y4)

if __name__ == '__main__':
    main()

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

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

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):
x_1, y_1, x_2, y_2 = map(int, input().split())

x = x_2-x_1
y = y_2-y_1
x_3, y_3 = x_2-y, y_2+x
x_4, y_4 = x_3-x, y_3-y
print(x_3, y_3, x_4, y_4)

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

v23 = (-(y2 - y1), x2 - x1)
x3 = x2 + v23[0]
y3 = y2 + v23[1]

v34 = (-(y3 - y2), x3 - x2)
x4 = x3 + v34[0]
y4 = y3 + v34[1]

print(x3, y3, x4, y4)

Solution (Python):
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("{0} {1} {2} {3}".format(x3,y3,x4,y4))

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())
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())

vec = [x2-x1,y2-y1]

x3 = x2 - vec[1]
y3 = y2 + vec[0]
x4 = x3 - vec[0]
y4 = y3 - vec[1]

print(x3,y3,x4,y4)

Solution (Python):
import numpy as np
x1,y1,x2,y2=[int(a) for a in input().split()]
p1 = np.array([x1,y1])
p2 = np.array([x2,y2])
v1 = p2-p1
v2 = np.array([-v1[1],v1[0]])
p3 = p2+v2
p4 = p3+(-v1)
print(" ".join([str(v) for v in list(p3)+list(p4)]))

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
vec = [x2-x1,y2-y1]
to23 = [-1*vec[1],vec[0]]
to34 = [-1*vec[0],-1*vec[1]]

print(x2+to23[0],y2+to23[1],x2+to23[0]+to34[0],y2+to23[1]+to34[1])

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