ZhenlongDai/ACPR huggingface dataset:
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
X = abs(x1 - x2)
Y = abs(y1 - y2)

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

print(x3, y3, x4, y4)

Failing test case input:
0 5 3 3

Expected output:
5 6 2 8


Actual output:
1 6 -2 4


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

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

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

print(x3, y3, x4, y4)

Problem: p03265
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
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='')

Failing test case input:
2 -1 1 7

Expected output:
-7 6 -6 -2


Actual output:
-7 6-6 -2

Fixed submission (verdict: Accepted):
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=' ')

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, c, d = map(int, input().split())
x = a - c
y = b - d
print(c - y, d + x, a - y, b + x)

Failing test case input:
0 22 3 1

Expected output:
24 4 21 25


Actual output:
-18 -2 -21 19


Fixed submission (verdict: Accepted):
a, b, c, d = map(int, input().split())
x = c - a
y = d - b
print(c - y, d + x, a - y, b + x)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
print(x1+(x2-x1)-abs(y1-y2),y2-(x1-x2),x1-abs(y1-y2),y1+(x2-x1))

Failing test case input:
0 22 8 2

Expected output:
28 10 20 30


Actual output:
-12 10 -20 30


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
print(x2+y1-y2,y2+x2-x1,x1+y1-y2,y1+x2-x1)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()


Failing test case input:
-1 -6 -1 21

Expected output:
-28 21 -28 -6


Actual output:
-28 21 26 21


Fixed submission (verdict: Accepted):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
xyList = list(map(int,input().split()))
print(xyList)
x = xyList[2]-xyList[0]
y = xyList[3]-xyList[1]
print(xyList[2]-y,xyList[3]+x,xyList[0]-y,xyList[1]+x)


Failing test case input:
0 -4 1 3

Expected output:
-6 4 -7 -3


Actual output:
[0, -4, 1, 3]
-6 4 -7 -3


Fixed submission (verdict: Accepted):
xyList = list(map(int,input().split()))
x = xyList[2]-xyList[0]
y = xyList[3]-xyList[1]
print(xyList[2]-y,xyList[3]+x,xyList[0]-y,xyList[1]+x)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()


Failing test case input:
-1 -2 0 3

Expected output:
-5 4 -6 -1


Actual output:
-5 4 -6 2


Fixed submission (verdict: Accepted):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c,d = map(int,input().split())
print(c+(d-b),d-(c-a),c+d-b-c+a,d-c+a-d+b)

Failing test case input:
-8 0 0 11

Expected output:
-11 19 -19 8


Actual output:
11 3 3 -8


Fixed submission (verdict: Accepted):
a,b,c,d = map(int,input().split())
print(c-(d-b),d+(c-a),c-d+b-c+a,d+c-a-d+b)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, end='')
print(y2+x2-x1, end='')
print(x2-y2+y1-x2+x1, end='')
print(y2+x2-x1-y2+y1, end='')

Failing test case input:
0 -2 0 2

Expected output:
-4 2 -4 -2


Actual output:
-42-4-2

Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, end=' ')
print(y2+x2-x1, end=' ')
print(x2-y2+y1-x2+x1, end=' ')
print(y2+x2-x1-y2+y1, end='')

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=list(map(int,input().split()))
ans_l=[n[2]+n[1]-n[3],n[3]-n[0]+n[2],n[0]+n[1]-n[3],n[1]-n[0]+n[2]]
print(ans_l)


Failing test case input:
-4 -1 0 11

Expected output:
-12 15 -16 3


Actual output:
[-12, 15, -16, 3]


Fixed submission (verdict: Accepted):
n=list(map(int,input().split()))
print(n[2]+n[1]-n[3],n[3]-n[0]+n[2],n[0]+n[1]-n[3],n[1]-n[0]+n[2])

Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
l = abs(x1-x2)
h = abs(y1-y2)

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

print(x3, y3, x4, y4)

Failing test case input:
1 -46 -59 26

Expected output:
-131 -34 -71 -106


Actual output:
-131 86 -71 14


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
l = x2-x1
h = y2-y1

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

print(x3, y3, x4, y4)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
k = abs(y2-y1)
m = x2-x1
print(k,m)
print(x2-k,y2-m,x1-k,y1-m)

Failing test case input:
-2 -2 -1 11

Expected output:
-14 12 -15 -1


Actual output:
13 1
-14 10 -15 -3


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
k = abs(y2-y1)
m = abs(x2-x1)
print(x2-k,y2-m,x1-k,y1-m)

Failing test case input:
0 5 3 3

Expected output:
5 6 2 8


Actual output:
1 0 -2 2


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
print((x2-(y2-y1)),(y2-(x1-x2)),(x1-(y2-y1)),(x1-(x1-x2)))


Failing test case input:
-3 -1 0 11

Expected output:
-12 14 -15 2


Actual output:
-12 14 -15 0


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
print((x2-(y2-y1)),(y2-(x1-x2)),(x1-(y2-y1)),(y1-(x1-x2)))

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def test():
    x1,y1,x2,y2 = map(int,input().split())
    x = abs(x2-x1)
    y = abs(y2-y1)
    print(x2-y,y2+x,x1-y,y1+x)


if __name__ == "__main__":
    test()


Failing test case input:
2 -2 1 5

Expected output:
-6 4 -5 -3


Actual output:
-6 6 -5 -1


Fixed submission (verdict: Accepted):
def test():
    x1,y1,x2,y2 = map(int,input().split())
    x = x2-x1
    y = y2-y1
    print(x2-y,y2+x,x1-y,y1+x)


if __name__ == "__main__":
    test()

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c,d=map(int,input().split())
print(c+b-d,d+b-a,a+b-d,b+c-a)

Failing test case input:
2 -1 1 5

Expected output:
-5 4 -4 -2


Actual output:
-5 2 -4 -2


Fixed submission (verdict: Accepted):
a,b,c,d=map(int,input().split())
print(c+b-d,d+c-a,a+b-d,b+c-a)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
k = abs(y2-y1)
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)

Failing test case input:
0 22 7 3

Expected output:
26 10 19 29


Actual output:
-12 10 -19 29


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2-(x2-x1)
x4=x3-(y3-y2)
y4=y3-(x3-x2)
lst=[x3,y3,x4,y4]
print(*lst)

Failing test case input:
-1 -2 0 3

Expected output:
-5 4 -6 -1


Actual output:
-5 2 -4 7


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2+(x2-x1)
x4=x1+(y1-y2)
y4=y1-(x1-x2)
lst=[x3,y3,x4,y4]
print(*lst)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
a=abs(x1-x2)
b=abs(y1-y2)
if(y1<=y2):
  if(x1<=x2):
    print(x2-b,y2+a,x1-b,y1+a)
    
  else:
    print(x2-b,y2-a,x1-b,y1-a)
    
else:
  if(x1<=x2):
    print(x2+a,y2+b,x1+a,y1+b)
    
  else:
    print(x2+b,y2+a,x1+b,y1-a)
    

Failing test case input:
0 22 3 0

Expected output:
25 3 22 25


Actual output:
6 22 3 44


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
a=abs(x1-x2)
b=abs(y1-y2)
if(y1<=y2):
  if(x1<=x2):
    print(x2-b,y2+a,x1-b,y1+a)
    
  else:
    print(x2-b,y2-a,x1-b,y1-a)
    
else:
  if(x1<=x2):
    print(x2+b,y2+a,x1+b,y1+a)
    
  else:
    print(x2+b,y2-a,x1+b,y1-a)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(map(int,input().split()))

p1 = (int(n[0]) + int(n[1]) * 1j)
p2 = (int(n[2]) + int(n[3]) * 1j)

p3 = (p2 - p1) * 1j + p2
p4 = p3 + (p1 - p2)

print(p3.real, p3.imag, p4.real, p4.imag)


Failing test case input:
-2 -1 0 11

Expected output:
-12 13 -14 1


Actual output:
-12.0 13.0 -14.0 1.0


Fixed submission (verdict: Accepted):
n = list(map(int,input().split()))

p1 = (int(n[0]) + int(n[1]) * 1j)
p2 = (int(n[2]) + int(n[3]) * 1j)

p3 = (p2 - p1) * 1j + p2
p4 = p3 + (p1 - p2)

print(int(p3.real), int(p3.imag), int(p4.real), int(p4.imag))

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
k = abs(y2)+abs(y1)
m = abs(x2)+abs(x1)
print(x2-k,y2+m,x1-k,y1+m)

Failing test case input:
2 1 6 6

Expected output:
1 10 -3 5


Actual output:
-1 14 -5 9


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
d1 = abs(x2-x1)
d2 = abs(y2-y1)
x3 = x2 + d2
y3 = y2 + d1
x4 = x1 + d1
y4 = y1 + d2
print(str("x3 y3 x4 y4"))


Failing test case input:
1 -46 -59 12

Expected output:
-117 -48 -57 -106


Actual output:
x3 y3 x4 y4


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
d1 = x2-x1
d2 = y2-y1
x3 = x2 - d2
y3 = y2 + d1
x4 = x1 - d2
y4 = y1 + d1
print(x3,y3,x4,y4)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())

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

Failing test case input:
-12 0 0 11

Expected output:
-11 23 -23 12


Actual output:
-11 -1 -23 -12


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
-1 -2 -1 10

Expected output:
-13 10 -13 -2


Actual output:
-9 10 -9 -2


Fixed submission (verdict: Accepted):
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)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
p = input().split(" ")
x1 = int(p[0])
y1 = int(p[1])
x2 = int(p[2])
y2 = int(p[3])

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

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

Failing test case input:
2 3 3 3

Expected output:
3 4 2 4


Actual output:
3 3 3 3


Fixed submission (verdict: Accepted):
p = input().split(" ")
x1 = int(p[0])
y1 = int(p[1])
x2 = int(p[2])
y2 = int(p[3])

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

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
dx=x2-x1
dy=y2-y1
x3=x2-dy
y3=x2+dx
x4=x3-dx
y4=y3-dy
print(x3,y3,x4,y4)

Failing test case input:
-2 -2 -1 10

Expected output:
-13 11 -14 -1


Actual output:
-13 0 -14 -12


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
dx = x2-x1; dy = y2-y1
print(x2-dy, y2+dx, x1-dy, x2+dx)

Failing test case input:
0 -6 -1 12

Expected output:
-19 11 -18 -7


Actual output:
-19 11 -18 -2


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
dx = x2-x1; dy = y2-y1
print(x2-dy, y2+dx, x1-dy, y1+dx)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int,input().split())

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

print(x3,y3,x4,y4)

Failing test case input:
-6 -1 0 11

Expected output:
-12 17 -18 5


Actual output:
-6 -1 -18 -7


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int,input().split())

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

print(x3, y3, x4, y4)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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(C.real, C.imag, D.real, D.imag)
if __name__ == '__main__':
    main()

Failing test case input:
1 22 8 2

Expected output:
28 9 21 29


Actual output:
28.0 9.0 21.0 29.0


Fixed submission (verdict: Accepted):
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()
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().rstrip().split())
xx = x2-x1
yy = abs(y2-y1)
print(x2-yy,y2+xx,end=" ")
print(x2-yy-xx,y2+xx-yy)

Failing test case input:
0 22 8 2

Expected output:
28 10 20 30


Actual output:
-12 10 -20 -10


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().rstrip().split())
xx = x2-x1
yy = y2-y1
print(x2-yy,y2+xx,end=" ")
print(x2-yy-xx,y2+xx-yy)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
x = x1-x2
y = y2-y1
print(x2-y, y2+x , x1-y, y1-x)

Failing test case input:
0 22 3 3

Expected output:
22 6 19 25


Actual output:
22 0 19 25


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
x = x1-x2
y = y2-y1
print(x2-y, y2-x , x1-y, y1-x)

Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
diffy = x2-x1
diffx = y2-y1
print(diffy,diffx)
print(x2-diffx,y2+diffy,x1-diffx,y1+diffy)

Failing test case input:
0 0 0 1

Expected output:
-1 1 -1 0

Actual output:
0 1
-1 1 -1 0


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
diffy = x2-x1
diffx = y2-y1

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
a=abs(x1-x2)
b=abs(y1-y2)
if(y1<=y2):
  if(x1<=x2):
    print(x2-b,y2+a,x1-b,y1+a)
  else:
    print(x2-b,y2-a,x1-b,y1-a)
else:
  if(x1<=x2):
    print(x2+a,y2+b,x1+a,y1+b)
  else:
    print(x2+b,y2+a,x1+b,y1-a)

Failing test case input:
2 6 8 5

Expected output:
9 11 3 12


Actual output:
14 6 8 7


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
a=abs(x1-x2)
b=abs(y1-y2)
if(y1<=y2):
  if(x1<=x2):
    print(x2-b,y2+a,x1-b,y1+a)
    
  else:
    print(x2-b,y2-a,x1-b,y1-a)
    
else:
  if(x1<=x2):
    print(x2+b,y2+a,x1+b,y1+a)
    
  else:
    print(x2+b,y2-a,x1+b,y1-a)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
x1,y1,x2,y2 = list(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)

Failing test case input:
0 -12 0 12

Expected output:
-24 12 -24 -12


Actual output:
24 12 24 -12


Fixed submission (verdict: Accepted):
import sys
x1,y1,x2,y2 = list(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)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def actual(x1, y1, x2, y2):
    a = x2 - x1
    b = y2 - y1

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

    return x3, y3, x4, y4

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

Failing test case input:
1 -46 0 12

Expected output:
-58 11 -57 -47


Actual output:
(-58, 11, -57, -47)


Fixed submission (verdict: Accepted):
def actual(x1, y1, x2, y2):
    a = x2 - x1
    b = y2 - y1

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

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

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1 , y1, x2, y2 = map(int, input().split())

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

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

Failing test case input:
-2 0 -1 11

Expected output:
-12 12 -13 1


Actual output:
-12 11 -12 0


Fixed submission (verdict: Accepted):
x1 , y1, x2, y2 = map(int, input().split())

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
1 5 8 5

Expected output:
8 12 1 12


Actual output:
8 -2 1 -2


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
x = x2 - x1
y = y2 - y1
x3 = x2 - y
y3 = y2 + x
x4 = y1 - y
y4 = y1 + x
print(x3, y3, x4, y4)

Failing test case input:
2 22 8 2

Expected output:
28 8 22 28


Actual output:
28 8 42 28


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c,d=map(int,input().split())
y,x=c-a,d-b
print("{} {} {} {}".format(c+x,d+y,a-x,b-y))

Failing test case input:
2 -1 1 5

Expected output:
-5 4 -4 -2


Actual output:
7 4 -4 0


Fixed submission (verdict: Accepted):
a,b,c,d=map(int,input().split())
y,x=c-a,d-b
print("{} {} {} {}".format(c-x,d+y,a-x,b+y))

Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
0 22 6 3

Expected output:
25 9 19 28


Actual output:
-19 -3 -25 16


Fixed submission (verdict: Accepted):
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)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
k = abs(abs(y2)-abs(y1))
m = abs(abs(x2)-abs(x1))
print(x2-k,y2+m,x1-k,y1+m)

Failing test case input:
0 -15 1 12

Expected output:
-26 13 -27 -14


Actual output:
-2 13 -3 -14


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
k = y2-y1
m = x2-x1
print(x2-k,y2+m,x1-k,y1+m)

Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    x=a[2]-a[0]
    y=a[3]-a[1]

    print(str(a[2]-y)+" "+ str(a[3]+x)+" "+str(a[3]+x)+" "+str(a[1]+x)+" ")

Failing test case input:
1 5 3 5

Expected output:
3 7 1 7


Actual output:
3 7 7 7 


Fixed submission (verdict: Accepted):
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    x=a[2]-a[0]
    y=a[3]-a[1]

    print(str(a[2]-y)+" "+ str(a[3]+x)+" "+str(a[0]-y)+" "+str(a[1]+x)+" ")

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
print(x2+y2-y1, y2+x2-x1, x1+y1-y2, y1-x1+x2)


Failing test case input:
1 -41 -59 26

Expected output:
-126 -34 -66 -101


Actual output:
8 -34 -66 -101


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
print(x2-y2+y1, y2+x2-x1, x1+y1-y2, y1-x1+x2)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
xsa = x2 - x1
ysa = y2 - y1
x3 = x2 - ysa
y3 = y2 + xsa
x4 = x1 - ysa
y4 = y1 + xsa
print(x3,end="")
print(y3,end="")
print(x4,end="")
print(y4)

Failing test case input:
0 0 -1 2

Expected output:
-3 1 -2 -1


Actual output:
-31-2-1


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
xsa = x2 - x1
ysa = y2 - y1
x3 = x2 - ysa
y3 = y2 + xsa
x4 = x1 - ysa
y4 = y1 + xsa
print(x3,end=" ")
print(y3,end=" ")
print(x4,end=" ")
print(y4)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = [int(x) for x in input().split()]
a=A[2]-A[0]
b=A[3]-A[1]
print(A[2]-b,A[3]+a,A[0]-b,A[0]+a)


Failing test case input:
-2 0 -1 11

Expected output:
-12 12 -13 1


Actual output:
-12 12 -13 -1


Fixed submission (verdict: Accepted):
A = [int(x) for x in input().split()]
a=A[2]-A[0]
b=A[3]-A[1]
print(A[2]-b,A[3]+a,A[0]-b,A[1]+a)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
nums = list(map(int, input().split()))
x = abs(nums[0] - nums[2])
y = abs(nums[1] - nums[3])

n1 = nums[2] - y
n2 = nums[3] + x
print(n1, end="")
print(" ", end="")
print(n2, end="")
print(" ", end="")
print(n1 - x, end="")
print(" ", end="")
print(n2 - y, end="")
print(" ", end="")

Failing test case input:
2 0 1 5

Expected output:
-4 4 -3 -1


Actual output:
-4 6 -5 1 

Fixed submission (verdict: Accepted):
nums = list(map(int, input().split()))
x = (nums[2] - nums[0])
y = (nums[3] - nums[1])

n1 = nums[2] - y
n2 = nums[3] + x
print(n1, end="")
print(" ", end="")
print(n2, end="")
print(" ", end="")
print(n1 - x, end="")
print(" ", end="")
print(n2 - y)
Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

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

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


Failing test case input:
1 -46 0 12

Expected output:
-58 11 -57 -47


Actual output:
48 -12 1 0


Fixed submission (verdict: Accepted):

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

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

x = x2 - x1
y = y2 - y1

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

Failing test case input:
2 0 -1 5

Expected output:
-6 2 -3 -3


Actual output:
-6 2 -3 -4


Fixed submission (verdict: Accepted):

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

x = x2 - x1
y = y2 - y1

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def resolve():
    x1, y1, x2, y2 = map(int, input().split())
    print(x2-abs(y2-y1), y2+x2-x1, x1-abs(y2-y1), y1+x2-x1)
resolve()

Failing test case input:
0 22 3 3

Expected output:
22 6 19 25


Actual output:
-16 6 -19 25


Fixed submission (verdict: Accepted):
def resolve():
    x1, y1, x2, y2 = map(int, input().split())
    print(x2-y2+y1, y2+x2-x1, x1-y2+y1, y1+x2-x1)
resolve()

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

Failing test case input:
1 5 5 5

Expected output:
5 9 1 9


Actual output:
5 5 5 5


Fixed submission (verdict: Accepted):

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
print(x2+y1-y2,y2-x1+x1,x1+y1-y2,y1-x1+x2)

Failing test case input:
1 6 8 5

Expected output:
9 12 2 13


Actual output:
9 5 2 13


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
print(x2+y1-y2,y2-x1+x2,x1+y1-y2,y1-x1+x2)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int,input().split())
deltax = x2 - x1
deltay = y2 - y1
x3 = x2 - deltay
y3 = y2 + deltax
x4 = x1 - deltay
y4 = y1 + deltax
print(x3, y3, x2, y2)

Failing test case input:
2 -1 1 7

Expected output:
-7 6 -6 -2


Actual output:
-7 6 1 7


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int,input().split())
deltax = x2 - x1
deltay = y2 - y1
x3 = x2 - deltay
y3 = y2 + deltax
x4 = x1 - deltay
y4 = y1 + deltax
print(x3, y3, x4, y4)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=[int(s) for s in input().split()]
(dx,dy)=(x2-x1,y2-y1)
print(x2-dy,y2-dx,x1-dy,y1-dx)

Failing test case input:
0 22 7 3

Expected output:
26 10 19 29


Actual output:
26 -4 19 15


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=[int(s) for s in input().split()]
(dx,dy)=(x2-x1,y2-y1)
print(x2-dy,y2+dx,x1-dy,y1+dx)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int, input().split())
len = abs(y1 - y2)

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

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

Failing test case input:
1 -46 -59 26

Expected output:
-131 -34 -71 -106


Actual output:
-131 26 -71 -46


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int, input().split())
ylen = y2 - y1
xlen = x2 - x1

x3 = x2 - ylen
y3 = y2 + xlen
x4 = x3 - xlen
y4 = y3 - ylen

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
x3=x2-(y2-y1)
y3=y2-(x2-x1)
x4=x1+(y1-y2)
y4=y1+(x1-x2)
lst=[x3,y3,x4,y4]
print(*lst)

Failing test case input:
2 3 3 3

Expected output:
3 4 2 4


Actual output:
3 2 2 2


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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())

diff_x = x2 - x1
diff_y = y2 - y1

x3 = x1 - diff_y
y3 = y1 + diff_x

x4 = x2 - diff_y
y4 = y2 + diff_x

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

Failing test case input:
-7 0 0 11

Expected output:
-11 18 -18 7


Actual output:
-18 7 -11 18


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())

diff_x = x2 - x1
diff_y = y2 - y1

x4 = x1 - diff_y
y4 = y1 + diff_x

x3 = x2 - diff_y
y3 = y2 + diff_x

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)


Failing test case input:
0 22 8 3

Expected output:
27 11 19 30


Actual output:
27 11 19 -8


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
-12 1 0 11

Expected output:
-10 23 -22 13


Actual output:
-10 -1 -22 13


Fixed submission (verdict: Accepted):
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)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2 = map(int,input().split())
h = max(abs(x2-x1),abs(y2-y1))
v = min(abs(x2-x1),abs(y2-y1))
if x1 > x2:
  if y1 > y2: print(x2+h,y2-v,x1+h,y1-v)
  else:print(x2-v,y2-h,x1-v,y1-h)
else:
  if y1 > y2: print(x2+v,y2+h,x1+v,y1+h)
  else:print(x2-h,y2+v,x1-h,y1+v)

Failing test case input:
2 0 1 5

Expected output:
-4 4 -3 -1


Actual output:
0 0 1 -5


Fixed submission (verdict: Accepted):
x1,y1,x2,y2 = map(int,input().split())
h = abs(x2-x1)
v = abs(y2-y1)
if x1 > x2:
  if y1 > y2: print(x2+v,y2-h,x1+v,y1-h)
  else:         print(x2-v,y2-h,x1-v,y1-h)
else:
  if y2 > y1: print(x2-v,y2+h,x1-v,y1+h)
  else:         print(x2+v,y2+h,x1+v,y1+h)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
-4 -1 0 11

Expected output:
-12 15 -16 3


Actual output:
12 7 8 -5


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,y1,x2,y2=map(int,input().split())
x=x2-x1
y=y2-y1
print(x2-y, y2+x, x1-y1, y1+x)

Failing test case input:
-2 -2 -1 10

Expected output:
-13 11 -14 -1


Actual output:
-13 11 0 -1


Fixed submission (verdict: Accepted):
x1,y1,x2,y2=map(int,input().split())
x=x2-x1
y=y2-y1
print(x2-y, y2+x, x1-y, y1+x)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
if dx >= 0 and dy < 0:
  x3, y3 = x1 + dy, y1 + dx
  x4, y4 = x2 + dy, y2 + dx
elif dx < 0 and dy >= 0:
  x3, y3 = x2 - dy, y2 + dx
  x4, y4 = x1 - dy, y1 + dx
else:
  x3, y3 = x2 - dy, y2 + dx
  x4, y4 = x1 - dy, y1 + dx
  
print(x3, y3, x4, y4)

Failing test case input:
0 22 3 0

Expected output:
25 3 22 25


Actual output:
-22 25 -19 3


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())
dx = x2 - x1
dy = y2 - y1
if (dx < 0 and dy >= 0) or (dx >= 0 and dy < 0):
  x3, y3 = x2 - dy, y2 + dx
  x4, y4 = x1 - dy, y1 + dx
else:
  x3, y3 = x2 - dy, y2 + dx
  x4, y4 = x1 - dy, y1 + dx
  
print(x3, y3, x4, y4)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = map(int, input().split())
a=list(l)
x1=a[0]
y1=a[1]
x2=a[2]
y2=a[3]
x=x2-x1
y=y2-y1
x3=x2-y
y3=y2+x
x4=x1-y
y4=y1+x
c=[x3, y3, x4, y4]
print(c)

Failing test case input:
1 5 3 5

Expected output:
3 7 1 7


Actual output:
[3, 7, 1, 7]


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

Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c,d = map(int,input().split())
print(c+b-d,d+a-c,a+b-d,b+a-c)

Failing test case input:
-1 -2 0 2

Expected output:
-4 3 -5 -1


Actual output:
-4 1 -5 -3


Fixed submission (verdict: Accepted):
a,b,c,d = map(int,input().split())
print(c+b-d,d+c-a,a+b-d,b+c-a)
Problem: p03265
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x1, y1, x2, y2 = list(map(int, input().split()))
vector = (x2-x1, y2-y1)
x3, y3 = x1-vector[1], y1+vector[0]
x4, y4 = x2-vector[1], y2+vector[0]
print(x3, y3, x4, y4)

Failing test case input:
-1 -2 -1 10

Expected output:
-13 10 -13 -2


Actual output:
-13 -2 -13 10


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
-6 -2 0 11

Expected output:
-13 17 -19 4


Actual output:
13 5 7 -8


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1,x2,y1,y2 = map(int,input().split())
x3 = x2 + (y1 - y2)
y3 = y2 + (x2 - x1)
x4 = x1 + (x2 - x1)
y4 = y1 + (y1 - y2)
print(x3,y3,x4,y4)

Failing test case input:
0 0 2 3

Expected output:
-1 5 -3 2


Actual output:
-1 3 0 1


Fixed submission (verdict: Accepted):
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)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int, input().split())
hen = y1 - y2
x3 = x2 + hen
y3 = y2
x4 = x1 + hen
y4 = y1
print(x3, y3, x4, y4)

Failing test case input:
1 6 8 5

Expected output:
9 12 2 13


Actual output:
9 5 2 6


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int, input().split())

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

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x1, y1, x2, y2 = map(int,input().split())
dx = x2-x1
dy = y2-y1
print(x2-dy,y2+dx,x2-dy+dx,y2+dx-dy)

Failing test case input:
1 -46 -59 26

Expected output:
-131 -34 -71 -106


Actual output:
-131 -34 -191 -106


Fixed submission (verdict: Accepted):
x1, y1, x2, y2 = map(int,input().split())
dx = x2-x1
dy = y2-y1
print(x2-dy,y2+dx,x2-dy-dx,y2+dx-dy)

Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
2 2 6 2

Expected output:
6 6 2 6


Actual output:
2 6 -2 6


Fixed submission (verdict: Accepted):
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)
Problem: p03265
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)


Failing test case input:
1 -2 2 3

Expected output:
-3 4 -4 -1


Actual output:
7 2 -4 -1


Fixed submission (verdict: Accepted):
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)
Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
for n in t:
    if n < ans:
        ans = n
    ans += T 
print(ans)

Failing test case input:
9 10
0 3 6 5 100 110 268 272 311

Expected output:
59


Actual output:
65


Fixed submission (verdict: Accepted):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
for i in range(N - 1):
    if t[i + 1] - t[i] >= T:
        ans += T
    else:
        ans += (t[i + 1] - t[i])
    
print(ans + T)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T=map(int,input().split())
a=list(map(int,input().split()))
keep=0
ans=0

for i in range(N):
  if keep<=a[i]:
    ans+=T
    keep+=a[i]+T
print(ans)
    
    
  

Failing test case input:
2 8
0 5

Expected output:
13


Actual output:
8


Fixed submission (verdict: Accepted):
n,t=map(int,input().split())
a=list(map(int,input().split()))
keep=0
ans=0
for i in range(n):
    if keep<=a[i]:
        ans+=t
        keep=a[i]+t
    else:
        ans=ans+t-(keep-a[i])
        keep=a[i]+t
print(ans)

Problem: p03733
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,T = map(int,input().split());
t = [int(x) for x in input().split()];

end = 0;
ans = 0;
for i in range(N) :
    if end > t[i] :
        ans += t[i] + T - end;
    else :
        ans += T;
    end += t[i] + T;
    

print(ans); 

Failing test case input:
9 12
0 3 0 7 000 110 200 272 311

Expected output:
60


Actual output:
-527


Fixed submission (verdict: Accepted):
N,T = map(int,input().split());
t = [int(x) for x in input().split()];

end = 0;
ans = 0;
for i in range(N) :
    if end > t[i] :
        ans += t[i] + T - end;
    else :
        ans += T;
    end = t[i] + T;
    

print(ans);

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T = map(int,input().split())
P = list(map(int,input().split()))

total = T

for i in range(1,N):
  if total > P[i]:
    total += T - (total - P[i])
  else:
    total += T
    
print(total)

Failing test case input:
9 10
0 3 5 7 100 010 200 300 394

Expected output:
-33


Actual output:
50


Fixed submission (verdict: Accepted):
N,T = map(int,input().split())
P = list(map(int,input().split()))

total = T
now = T

for i in range(1,N):
  if now > P[i]:
    total += T - (now - P[i])
  else:
    total += T
  now = P[i] + T
    
print(total)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
e = 0
s = 0
for n in t[1:]:
    if s + T < n:
        s = n
        ans += e + T
    e = n
ans += (e - s) + T
print(ans)

Failing test case input:
4 0001001000
0 1101 1011100 1000000000

Expected output:
3004101


Actual output:
4015201


Fixed submission (verdict: Accepted):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
s = 0
e = T
for n in t[1:]:
    if e < n:
        ans += e - s
        s = n
    e = n + T
ans += e - s
print(ans)
Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


N=9
T=10
t=[0,3,5,7,100,110,200,300,311]
ans=0
t_diff=[t[i+1]-t[i] for i in range(N-1)]
print(t_diff)
for i in t_diff:
    if i>T:
        ans+=T
    else:
        ans+=i

print(ans+T)




Failing test case input:
4 1010000000
0 1010 1001000 1100001001

Expected output:
2021001000


Actual output:
[3, 2, 2, 93, 10, 90, 100, 11]
67


Fixed submission (verdict: Accepted):
N,T=map(int,input().split())
t= list(map(int,input().split()))
ans=0
t_diff=[t[i+1]-t[i] for i in range(N-1)]
for i in t_diff:
    if i>T:
        ans+=T
    else:
        ans+=i

print(ans+T)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T = map(int, input().split())
prev = 0
ans = 0
tt = list(map(int, input().split()))
for t in tt:
  if prev+T <= t:
    ans += T
  else:
    ans += (t - prev)
    prev = t

print(ans + T)
    


Failing test case input:
9 10
0 3 5 7 100 110 268 272 311

Expected output:
61


Actual output:
67


Fixed submission (verdict: Accepted):
N,T = map(int, input().split())
prev = 0
ans = 0
tt = list(map(int, input().split()))
for t in tt:
  if prev+T <= t:
    ans += T
  else:
    ans += (t - prev)
  prev = t

print(ans + T)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))
    
YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<=T:
        YU=ts[i]+T
    else:
        YU+=T
print (YU)

Failing test case input:
9 10
0 3 6 5 100 110 373 272 311

Expected output:
-46


Actual output:
292


Fixed submission (verdict: Accepted):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))

YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<T:
        YU+=T-(T-(ts[i]-ts[i-1]))
    else:
        YU+=T
print (YU)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,t=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in range(n-1):
    ans=min(a[i+1]-a[i],t)
ans+=t
print(ans)

Failing test case input:
4 1000000000
0 1100 1000000 1000000000

Expected output:
2000000000


Actual output:
1999000000


Fixed submission (verdict: Accepted):
n,t=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in range(n-1):
    ans+=min(a[i+1]-a[i],t)
ans+=t
print(ans)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T=map(int,input().split())
print(sum([min(t,T)for t in map(int,input().split())])+T)

Failing test case input:
4 1000000010
0 1100 1000000 1000000000

Expected output:
2000000010


Actual output:
2001001110


Fixed submission (verdict: Accepted):
N,T=map(int,input().split())
t=list(map(int,input().split()))
print(sum([min(T,t[i]-t[i-1]) for i in range(1,N)])+T)
Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))

YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<T:
        YU+=T-ts[i]-ts[i-1]
    else:
        YU+=T
print (YU)

Failing test case input:
4 1100000000
0 1000 1000000 0000000000

Expected output:
1100000000


Actual output:
4397998000


Fixed submission (verdict: Accepted):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))

YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<T:
        YU+=T-(T-(ts[i]-ts[i-1]))
    else:
        YU+=T
print (YU)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

prev = None
ans = 0
for t in map(int, input().split()):
    if prev is not None:
        if t - prev < T:
            ans += t - prev
        else:
            ans += T
    prev = t
    print("ans:", ans)
ans += T


Failing test case input:
4 1100010000
0 1000 1000000 1000000000

Expected output:
2100010000


Actual output:
ans: 0
ans: 1000
ans: 1000000
ans: 1000000000


Fixed submission (verdict: Accepted):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

prev = None
ans = 0
for t in map(int, input().split()):
    if prev is not None:
        if t - prev < T:
            ans += t - prev
        else:
            ans += T
    prev = t
ans += T
print(ans)

Problem: p03733
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
N, T = map(int, input().split())
t = list(map(int, input().split()))

total = 0
for i in range(N):
    if t[i] <= T*i:
        total = t[i]
    else:
        total += T
print(total+T)

Failing test case input:
4 1010011000
0 1100 0101100 1100000000

Expected output:
2020123100


Actual output:
2110011000


Fixed submission (verdict: Accepted):
N, T = map(int, input().split())
t = list(map(int, input().split()))

t.append(10**10)
total = 0
for i in range(N):
    if t[i+1] - t[i] <= T:
        total += t[i+1] - t[i]
    else:
        total += T
print(total)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
e = 0
s = 0
for n in t[1:]:
    if e + T < n:
        s = n
        ans += e + T
    e = n
ans += (e - s) + T
print(ans)

Failing test case input:
4 0000001000
0 1100 1001100 1000000000

Expected output:
4000


Actual output:
1006200


Fixed submission (verdict: Accepted):
N, T = map(int, input().split())
t = list(map(int, input().split()))

ans = 0
s = 0
e = T
for n in t[1:]:
    if e < n:
        ans += e - s
        s = n
    e = n + T
ans += e - s
print(ans)
Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T = map(int,input().split())
P = list(map(int,input().split()))

total = T
now = T

for i in range(1,N):
  if total > P[i]:
    total += T - (now - P[i])
  else:
    total += T
  now = P[i] + T
    
print(total)

Failing test case input:
9 10
0 3 6 3 100 110 373 272 562

Expected output:
-48


Actual output:
63


Fixed submission (verdict: Accepted):
N,T = map(int,input().split())
P = list(map(int,input().split()))

total = T
now = T

for i in range(1,N):
  if now > P[i]:
    total += T - (now - P[i])
  else:
    total += T
  now = P[i] + T
    
print(total)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))
    
YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<T:
        YU=ts[i]+T
    else:
        YU+=T
print (YU)

Failing test case input:
9 10
0 3 5 7 100 110 268 272 311

Expected output:
61


Actual output:
292


Fixed submission (verdict: Accepted):
N,T=map(int,input().split())
a=list(input().split())
ts=[]
for _ in range (len(a)):
    ts.append(int(a[_]))

YU=T

for i in range(1,N):
    if ts[i]-ts[i-1]<T:
        YU+=T-(T-(ts[i]-ts[i-1]))
    else:
        YU+=T
print (YU)

Problem: p03733
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, T = map(int, input().split())
t = list(map(int, input().split()))

sum_second = 0
for i in range(1, N + 1):
    if (i == N):
        sum_second += T
        break
    if T > t[i] - sum_second:
        sum_second += t[i] - sum_second
    elif (T <= t[i] - sum_second):
        sum_second += T


print(sum_second)


Failing test case input:
9 10
0 3 5 7 100 010 200 300 394

Expected output:
-33


Actual output:
50


Fixed submission (verdict: Accepted):
N, T = map(int, input().split())
t = list(map(int, input().split()))

sum_second = 0
for i in range(N):
    if (i == N - 1):
        sum_second += T
        break

    if (t[i + 1] - t[i] <= T):
        sum_second += t[i + 1] - t[i]
    else:
        sum_second += T

    
    
    
    


print(sum_second)

Problem: p03733
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,T = map(int,input().split())
t = list(map(int,input().split()))
cnt = 0
for i in range(N):
  if i==0: 
    end = T 
  
  elif t[i]>end: 
    cnt+=T
  elif t[i]<=end:
    cnt+=min(t[i]-cnt,T)
    
  end = t[i]+T

cnt+=T 
print(cnt)

Failing test case input:
9 10
0 3 6 5 100 110 268 272 311

Expected output:
59


Actual output:
65


Fixed submission (verdict: Accepted):
N,T = map(int,input().split())
t = list(map(int,input().split()))
X = 0
for i in range(N):
  if i==0: 
    end = T 
  
  elif t[i]>end: 
    X+=T
  elif t[i]<=end:
    X+=t[i]-t[i-1]
    
  end = t[i]+T

X+=T 
print(X)