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
from collections import deque
import math

def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def array(n,val=0):
    return [val]*n
def matrix(row,columns,val):
    return [[val]*columns for _ in range(row)]

def solve():
    dx = x2-x1
    dy = y2-y1

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

if __name__=='__main__':
    x1,y1,x2,y2 = IL()
    solve()

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 = x2 - b - a
y4 = y2 + a - b

print(x3,y3,x4,y4)

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())


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

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

ans = [x3,y3,x4,y4]
print(*ans)

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


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

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

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

Solution (Python):
x1,y1,x2,y2 = map(int, input().split())
v12x, v12y = x2-x1, y2-y1
v14x, v14y = v12y*(-1), v12x
x4,y4 = x1+v14x, y1+v14y

x3,y3 = x4+v12x, y4+v12y

print(x3,y3,x4,y4)

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

Solution (Python):
from typing import List


def answer(x1: int, y1: int, x2: int, y2: int) -> List[int]:
    x = x2 - x1
    y = y2 - y1

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

    return [x3, y3, x4, y4]


def main():
    x1, y1, x2, y2 = map(int, input().split())
    x3, y3, x4, y4 = answer(x1, y1, x2, y2)
    print(x3, y3, x4, y4)


if __name__ == '__main__':
    main()

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

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

v=[x2-x1,y2-y1]
x,y=v[0],v[1]
v=[-y,x]
x3,y3=x2+v[0],y2+v[1]
x,y=v[0],v[1]
v=[-y,x]
x4,y4=x3+v[0],y3+v[1]
print(x3,y3,x4,y4)

Solution (Python):
import sys

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

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

Solution (Python):
a = list(map(int,input().split()))
x_inc = a[2] - a[0]
y_inc = a[3] - a[1]
print(a[2]-y_inc,a[3]+x_inc,a[0]-y_inc,a[1]+x_inc)

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

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

dx = x2 - x1
dy = y2 - y1

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

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

Solution (Python):
a,b,c,d = map(int,input().split())
s = c - a
t = d - b
x_3 = c - t
y_3 = d + s
x_4 = x_3 - s
y_4 = y_3 - t
print(str(x_3)+' '+str(y_3)+' '+str(x_4)+' '+str(y_4) )

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

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

Solution (Python):
x1, y1, x2, y2 = (int(i) for i in 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())
if y2>=y1 and x2>=x1:
    y3=y2+abs(x2-x1)
    x3=x2-abs(y2-y1)
elif y2>=y1 and x1>x2:
    x3=x2-abs(y2-y1)
    y3=y2-abs(x2-x1)
elif y1>y2 and x2>=x1:
    x3=x2+abs(y2-y1)
    y3=y2+abs(x2-x1)
elif y1>y2 and x1>x2:
    x3=x2+abs(y2-y1)
    y3=y2-abs(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())
difx = x2-x1
dify = y2-y1
x3 = x2 - dify
y3 = y2 + difx
x4 = x3 - difx
y4 = y3 - dify
print("{a} {b} {c} {d}".format(a=x3,b=y3,c=x4,d=y4))

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


def solve(a, b, c, d):
    x = c -a
    y = d -b
    return print(f"{c-y} {d + x} {a - y} {b + x}")



def main():
    a, b, c, d = map(int, input().split())
    solve(a, b, c, d)

if __name__ == '__main__':
    main()

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

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

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

s = math.sqrt((x1-x2) ** 2 + (y1-y2) ** 2)
a = math.atan2(y2-y1, x2-x1)

x3 = x2 - math.sin(a) * s
y3 = y2 + math.cos(a) * s

x4 = x1 - math.sin(a) * s
y4 = y1 + math.cos(a) * s

print(round(x3), round(y3), round(x4), round(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):
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())
x,y=c-a,d-b
print(c-y,d+x,a-y,b+x)

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

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

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

Solution (Python):
a=[int(x)for x in input().split()];print(*[sum(a)-2*a[3*(not i%2)]-a[i] for i in[0,1,2,3]])

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

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 math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    x1, y1, x2, y2 = LI()
    d = max(abs(x1-x2), abs(y1-y2))
    dx = abs(x1-x2)
    dy = abs(y1-y2)
    if x1 < x2 and y1 <= y2:
        x3 = x2 - dy
        x4 = x1 - dy
        y3 = y2 + dx
        y4 = y1 + dx
    elif x1 < x2 and y1 > y2:
        x3 = x2 + dy
        x4 = x1 + dy
        y3 = y2 + dx
        y4 = y1 + dx
    elif x1 >= x2 and y1 < y2:
        x3 = x2 - dy
        x4 = x1 - dy
        y3 = y2 - dx
        y4 = y1 - dx
    else:
        x3 = x2 + dy
        x4 = x1 + dy
        y3 = y2 - dx
        y4 = y1 - dx
    print(x3, y3, x4, y4)



main()

Solution (Python):
x1,y1,x2,y2 = map(int,input().split())
a = x2-x1
b = y2-y1
print(" ".join(map(str,[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 = x1-(y2-y1)
y4 = y1+(x2-x1)

print(x3,y3,x4,y4)

Solution (Python):
x1, y1, x2, y2 = tuple(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())

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

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

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

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

Solution (Python):

import sys
input=sys.stdin.readline

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

if __name__=="__main__":
    main()

Solution (Python):

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

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


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

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

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

Solution (Python):
import math
x1, y1, x2, y2 = [int(x) for x in input().split()]
x12 = (x2-x1)
y12 = (y2-y1)
L = math.sqrt((x12)**2+(y12)**2)
x3 = (x12-y12)+x1
y3 = (x12+y12)+y1
x4 = -y12+x1
y4 = x12+y1
print('{} {} {} {}'.format(x3, y3, x4, y4))

Solution (Python):
import sys
import copy
import math
import itertools
import numpy as np

l = [int(c) for c in input().split()]
a = l[0]
b = l[1]
c = l[2]
d = l[3]
x = c - a
y = d - b
print(c-y,d+x,a-y,b+x)

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

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())
a = X2 - X1
b = Y2 - Y1
X3 = X2 - b
Y3 = Y2 + a
X4 = X1 - b
Y4 = Y1 + a
print(X3,end=' ') 
print(Y3,end=' ')
print(X4,end=' ')
print(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())

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

print(f'{x3} {y3} {x4} {y4}')

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

x3 = x2 - ay
y3 = y2 + ax

x4 = x1 - ay
y4 = y1 + ax

print(x3,y3,x4,y4)

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


if __name__ == "__main__":
    main()

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 sys
import numpy as np
import numba
from numba import jit

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


def main(x1, x2, y1, y2):
    a = x1 + y1 * 1j
    b = x2 + y2 * 1j
    c = b + (b-a) * 1j
    d = a + (a-b) * (-1j)
    print(int(c.real), int(c.imag), int(d.real), int(d.imag))

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    x1, y1, x2, y2 = map(int, input().split())
    diff_x = x2 - x1
    diff_y = y2 - y1
    r = [x2 - diff_y, y2 + diff_x, x1 - diff_y, y1 + diff_x]
    print(*r, sep= ' ')
if __name__ == '__main__':
    main()

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

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


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

x = x_2 - x_1
y = y_2 - y_1

print(x_2-y, y_2+x, x_1-y, y_1+x)

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):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    x1, y1, x2, y2 = map(int, readline().split())
    p = x2 - x1
    q = y2 - y1

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

    print(x3, y3, x4, y4)


if __name__ == '__main__':
    main()

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

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


if __name__ == "__main__":
    main()

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

x3_1, x3_2 = x2 - abs(y2 - y1), x2 + abs(y2 - y1)
x4_1, x4_2 = x1 - abs(y2 - y1), x1 + abs(y2 - y1)
y3_1, y3_2 = y2 - abs(x2 - x1), y2 + abs(x2 - x1)
y4_1, y4_2 = y1 - abs(x2 - x1), y1 + abs(x2 - x1)

if x2 > x1 and y2 > y1:
    print(x3_1, y3_2, x4_1, y4_2)
elif x2 > x1 and y2 <= y1:
    print(x3_2, y3_2, x4_2, y4_2)
elif x2 <= x1 and y2 > y1:
    print(x3_1, y3_1, x4_1, y4_1)
elif x2 <= x1 and y2 <= y1:
    print(x3_2, y3_1, x4_2, y4_1)

Solution (Python):
xy = list(map(int, input().split()))
x = list(xy[i] for i in range(0, 4, 2))
y = list(xy[i] for i in range(1, 4, 2))
x1 = x[1]-x[0]
y1 = y[1]-y[0]
print(x[1]-y1, y[1]+x1, x[0]-y1, y[0]+x1)

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

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

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

Solution (Python):
x=[0]*4
y=[0]*4

x[0], y[0], x[1], y[1] = map(int, input().split())

xdist = x[1]-x[0]
ydist = y[1]-y[0]

x[2] = x[1]-ydist
y[2] = y[1]+xdist

x[3] = x[2]-xdist
y[3] = y[2]-ydist
    
print(x[2], y[2], x[3], y[3])

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

Solution (Python):
x1,y1,x2,y2=map(int,input().split())
x3,y3,x4,y4=100,100,100,100
if y2-y1==0 or x2-x1==0:
  if x2>x1:
    x3=x2
    y3=y2+(x2-x1)
    x4=x1
    y4=y3
  elif y2>y1:
    x3=x1-(y2-y1)
    y3=y2
    x4=x3
    y4=y1
  elif x1>x2:
    x3=x2
    y3=y2+(x2-x1)
    x4=x1
    y4=y3
  elif y1>y2:
    x3=x1-(y2-y1)
    y3=y2
    x4=x3
    y4=y1

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

print(x3,y3,x4,y4)

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

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

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

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


dx = y1 - y2
dy = x2 - x1

x3 = x2 + dx
y3 = y2 + dy

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

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

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

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

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(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())
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):
def get_ans(x1,y1,x2,y2):
    def_x = abs(x2-x1)
    def_y = abs(y2-y1)

    if x2 < x1 and y2 <= y1:
        x3 = x2+def_y
        y3 = y2-def_x
        x4 = x1+def_y
        y4 = y1-def_x 
    elif y2 < y1 and x1 <= x2:
        x3 = x2+def_y
        y3 = y2+def_x
        x4 = x1+def_y
        y4 = y1+def_x     
    elif x2 > x1 and y1 <= y2:
        x3 = x2-def_y
        y3 = y2+def_x
        x4 = x1-def_y
        y4 = y1+def_x 
    elif y2 > y1 and x1 >= x2:
        x3 = x2-def_y
        y3 = y2-def_x
        x4 = x1-def_y
        y4 = y1-def_x

    print(x3,y3,x4,y4)
    

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

Solution (Python):
import sys 

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

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):
import sys 

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

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

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("{} {} {} {}".format(e,f,g,h))

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())
dx = x2 - x1
dy = y2 - y1
xx3 = (x2 - dy, y2 + dx)
xx4 = (x1 - dy, y1 + dx)
print(*xx3, *xx4)

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

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

x = c-a
y = d-b

print(str(c-y)+" "+str(d+x)+" "+str(a-y)+" "+str(b+x))

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

x = x2 - x1
y = y2 - y1

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

print(x3, y3, x4, y4)

Solution (Python):
x,y,z,w = map(int, input().split())
u = (x-z,y-w)
v = (w-y, x-z)
x1, y1 = z - v[0] ,w - v[1]
z1,w1 = x1 + u[0], y1 + u[1]
print(x1, y1, z1, w1)

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

X = x2 - x1
Y = y2 - y1

ans = [x2 - Y, y2 + X, x1 - Y, y1 + X]

print(*ans)

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

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+(y1-y2)
y3=y2-(x1-x2)
x4=x3+(x1-x2)
y4=y3+(y1-y2)
Z=[str(x3),str(y3),str(x4),str(y4)]
print(' '.join(Z))

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

vec12 = (x2-x1, y2-y1)
vec23 = (y1-y2, x2-x1)
vec34 = (x1-x2, y1-y2)

x3,y3 = x2+vec23[0],y2+vec23[1]
x4,y4 = x3+vec34[0], y3+vec34[1]

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

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

vx = x2 - x1
vy = y2 - y1

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

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().split())
dx, dy = x2-x1, y2-y1
c = (x2-dy, y2+dx)
d = (x1-dy, y1+dx)
print(*c, *d)

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

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

Solution (Python):
xy=list(map(int,input().split()))
print(xy[2]-(xy[3]-xy[1]), xy[3]-(xy[0]-xy[2]), xy[0]-(xy[3]-xy[1]), xy[1]-(xy[0]-xy[2]))

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("{} {} {} {}".format(x3,y3,x4,y4))

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

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

Solution (Python):

def resolve():
    import sys
    input = sys.stdin.readline
    
    
    x1, y1, x2, y2 = [int(x) for x in input().rstrip().split(" ")]
    x = x2 - x1
    y = y2 - y1
    print(x2 - y, y2 + x, x1 - y, y1 + x)


if __name__ == "__main__":
    resolve()

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

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

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

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

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

print(x2 + bc[0], y2 + bc[1], x1 + bc[0], y1 + bc[1])

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


x2da = x2 - x1
y2da = y2 - y1

x4da = -y2da  
y4da = x2da

x4 = x4da + x1
y4 = y4da + y1


x1da = x1 - x2
y1da = y1 - y2

x3da = y1da
y3da = -x1da

x3 = x3da + x2
y3 = y3da + y2

print(x3, end=" ")
print(y3, end=" ")
print(x4, end=" ")
print(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):
def resolve():
    '''
    code here
    '''
    x1, y1, x2, y2 = [int(item) for item in input().split()]

    del_x = x2 - x1
    del_y = y2 - y1

    print(x2 - del_y, y2 + del_x, x2 - del_y - del_x, y2 + del_x - del_y)

if __name__ == "__main__":
    resolve()

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())
X=x2-x1
Y=y2-y1
print(f"{x2-Y} {y2+X} {x1-Y} {y1+X}")

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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


if __name__ == '__main__':
    main()

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

dis_x = x2 - x1
dis_y = y2 - y1

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

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)
A = [x3,y3,x4,y4]
print(*A)

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

x1,y1,x2,y2 = inpm()

a = x2 - x1
b = y1 - y2

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+(X1-X2)
Y4 = Y3+(Y1-Y2)
print(X3,Y3,X4,Y4)

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    x1, y1, x2, y2 = nm()
    print(x2 + y1 - y2, y2 - x1 + x2, y1 - y2 + x1, y1 - x1 + x2)


if __name__ == '__main__':
    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):
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())

vec = (x2 - x1, y2 - y1)

vec2 = (-vec[1], vec[0])
vec3 = (-vec2[1], vec2[0])

x3, y3 = (x2 + vec2[0], y2 + vec2[1])
x4, y4 = (x3 + vec3[0], y3 + vec3[1])

print(x3, y3, x4, y4)

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

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

vec = (x2 - x1, y2 - y1)

vec2 = (-vec[1], vec[0])
vec3 = (-vec2[1], vec2[0])

x3, y3 = (x2 + vec2[0], y2 + vec2[1])
x4, y4 = (x3 + vec3[0], y3 + vec3[1])

print(x3, y3, x4, y4)

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

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):
import os
import sys
import math
if os.environ.get("DEBUG") is not None:
    sys.stdin = open("in.txt", "r")
rl = sys.stdin.readline
rls = sys.stdin.readline().rstrip("\n")

x1, y1, x2, y2 = map(int, rls.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):
a,b,c,d=list(map(int,input().split()))
H=c-a
W=d-b
e=c-W
f=d+H
g=a-W
h=b+H
print(e,f,g,h,end="")

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

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

vector = (x2-x1, y2-y1)

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

print(x3, y3, x4, y4)

Solution (Python):
import math
x1, y1, x2, y2 = list(map(lambda a: int(a), input().split(" ")))
P1 = [x1, y1]
P2 = [x2, y2]
L12 = [P2[0] - P1[0], P2[1] - P1[1]]
L23 = [-L12[1], L12[0]]
P3 = [P2[0] + L23[0], P2[1] + L23[1]]
P4 = [P3[0] - L12[0], P3[1] - L12[1]]

print(" ".join([str(P3[0]), str(P3[1]), str(P4[0]), str(P4[1])]))

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

a, b = abs(x2 - x1), abs(y1 - y2)

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

print(x3, y3, x4, y4)