qyliang/CodeNanoFix huggingface dataset:
Buggy code:
xyz = list(map(int,input().split()))
xyz[0] ,xyz[1] = xyz[1],xyz[0]
xyz[0], xyz[2] = xyz[2], xyz[0]
print(xyz)

Fixed code:
xyz = list(map(int,input().split()))
xyz[0] ,xyz[1] = xyz[1],xyz[0]
xyz[0], xyz[2] = xyz[2], xyz[0]
print(*xyz)
Buggy code:
n = list(map(int,input().split()))
m = []
for i in range(2):
    m.append(n[i])
    n.pop(i)
    n.append(m[i])
  
print(*n)

Fixed code:
n = list(map(int,input().split()))
m = []
for i in range(2):
    m.append(n[0])
    n.pop(0)
    
n.append(m[0])
n.append(m[1])
  
print(*n)
Buggy code:
A,B,C = map(int , input().split())
print(C,B,A)

Fixed code:

A, B, C = map(int, input().split())

print(C,A,B)
Buggy code:
X, Y, Z = map(int, input().split())
print(Z X Y)

Fixed code:
X, Y, Z = map(int, input().split())

X_orig = X
X = Y
Y = X_orig

X_orig = X
X = Z
Z = X_orig

print(X, Y, Z)
Buggy code:
inputline = list(map(lambda x:int(x), input().split(" ")))
print(inputline[1], inputline[2], inputline[0])

Fixed code:
inputline = list(map(lambda x:int(x), input().split(" ")))
print(inputline[2], inputline[0], inputline[1])
Buggy code:
x,y,z=map(int,input().split()):
print(z,x,y)

Fixed code:
x, y, z = map(int, input().split())
x,y = y,x 
x,z = z,x 
print(x, y, z)
Buggy code:
X,Y,Z = map(int,input().split())
print(Z X Y)

Fixed code:
X, Y, Z = map(int,input().split())

w = X
X = Y
Y = w
w = Z
Z = X
X = w

print(X ,Y ,Z)
Buggy code:
import sys
import os
import bisect, collections, copy, itertools, math, string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int, input().split()))
def LS(): return list(input().split())



def solve():
	ABC = LI()
    
    def swap(i, j):
      tmp = ABC[i]
      ABC[i] = ABC[j]
      ABC[j] = tmp
      
    swap(0, 1)
    swap(0, 2)
    print(ABC[0], ABC[1], ABC[2])
    
    
	
if __name__ == '__main__':
	solve()


Fixed code:
import sys
import os
import bisect, collections, copy, itertools, math, string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int, input().split()))
def LS(): return list(input().split())

def solve():
	ABC = LI()

	def swap(i, j):
		tmp = ABC[i]
		ABC[i] = ABC[j]
		ABC[j] = tmp

	swap(0, 1)
	swap(0, 2)

	print(ABC[0], ABC[1], ABC[2])
	
if __name__ == '__main__':
	solve()
Buggy code:
X, Y, Z = map(int, input().split())
print('{} {} {}'.format(Y, Z, X))

Fixed code:
X, Y, Z = map(int, input().split())
print('{} {} {}'.format(Z, X, Y))
Buggy code:
A = list(map(int, input().split()))
print(A[2],A[0],A[1])
print(A)


Fixed code:
A = list(map(int, input().split()))
print(A[2],A[0],A[1])
Buggy code:
X,Y,Z = int(input().split())
print('{} {} {}'.format(Z,X,Y))

Fixed code:
X,Y,Z = map(int, input().split())
print('{} {} {}'.format(Z,X,Y))
Buggy code:
a,b,c = map(int,input().split())
print(b,c,a)

Fixed code:
a,b,c  = map(int,input().split())
print(c,a,b)
Buggy code:
a = list(map(int, input().split()))
print("{0} {1} {2}".format(a[2], a[0], [1]))

Fixed code:
a = list(map(int, input().split()))
print("{0} {1} {2}".format(a[2], a[0], a[1]))
Buggy code:
# input
A, B, C = map(int, input().split())

# change box
tmp = A
A = B
B = tmp

tmp = A
A = C
C = tmp
    

# output
print("{} {} {]".format(A, B, C))

Fixed code:
# input
A, B, C = map(int, input().split())

# change box
tmp = A
A = B
B = tmp

tmp = A
A = C
C = tmp


# output
print("{} {} {}".format(A, B, C))
Buggy code:
C,B,A = map(int, input().split())
print(A,B,C)

Fixed code:
A,B,C = map(int, input().split())
A,B = B,A
A,C = C,A
print(A, B, C)
Buggy code:
a, b, c = map(int, input().split(' '))
print('{} {} {}'.format(b, c, a))


Fixed code:
a, b, c = map(int, input().split(' '))
print('{} {} {}'.format(c, a, b))
Buggy code:
import math

S =  list(map(int,input().split()))
X = S[0]
Y = S[1]
Z = S[2]
S[0],S[1] = S[1],S[0]
S[0],S[2] = S[2],S[0]
print(S)

Fixed code:
import math

S =  list(map(int,input().split()))
X = S[0]
Y = S[1]
Z = S[2]
S[0],S[1] = S[1],S[0]
S[0],S[2] = S[2],S[0]
print(S[0],S[1],S[2])
Buggy code:
def main():
    x, y, z = map(int, input().split())
    print(x,z,y)

if __name__ == "__main__":
    main()

Fixed code:
def main():
    x, y, z = map(int, input().split())
    print(z,x,y)

if __name__ == "__main__":
    main()
Buggy code:
from sys import stdin, stdout
l = list(map(int, stdin.readline().rstrip().split(' ')))
print(l)
f=[]
i=-1
n = 0
while(n<len(l)):
  
  f.append(l[i])
  i = i+1
  n= n+1
print(f)

Fixed code:
from sys import stdin, stdout
l = list(map(int, stdin.readline().rstrip().split(' ')))
f=[]
i=-1
n = 0
while(n<len(l)):
  f.append(l[i])
  i = i+1
  n= n+1
print(*f,sep=" ")
Buggy code:
a,b,c = map(int,input().split())
a,b = b,c
a,c = c,a
print(a,b,c)

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

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

a, b = b, a
a, c = c, a

print(a + " " + b + " " + c)

Fixed code:
a,b,c=map(int,input().split())
print(str(c)+" "+str(a)+" "+str(b))
Buggy code:
X, Y, Z = map(int, input().split())

print(Z, Y, X)

Fixed code:
X, Y, Z = map(int, input().split())

Y, X = X, Y
Z, X = X, Z
print(X, Y, Z)
Buggy code:
a,b,c=(int(x) for x in input().split())

print(str(a)+" "+str(c)+" "+str(b))


Fixed code:
a,b,c=(int(x) for x in input().split())

print(str(c)+" "+str(a)+" "+str(b))
Buggy code:
a, b, c = [int(x) for x in input().split()
a, b = b, a
a, c = c, a
print (a,b,c)

Fixed code:
a, b, c = [int(x) for x in input().split()]
a, b =b, a
a, c = c, a
print (a,b,c)
Buggy code:
z,x,c=map(int, input.split())
print(str(z)+" "+str(x)+" "+str(y))

Fixed code:
x, y, z = map(int, input().split())
x, y = y, x
x, z = z, x

print(str(x) + ' ' + str(y) + ' ' + str(z))
Buggy code:
a,b,c=map(int, input.split())
print(str(a b c))

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

print(c,a,b)
Buggy code:
l = map(int,input().split())

print(l[2],l[0],l[1])

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

print(l[2],l[0],l[1])
Buggy code:
X, Y, Z = list(map(int, input().split()))
print(Z, Y, X)

Fixed code:
X, Y, Z = list(map(int, input().split()))
print(Z, X, Y)
Buggy code:
a, b, c = map(int, input().split())

a = b, b = a
a = c, c = a
print(a b c)


Fixed code:
a,b,c=map(int,input().split());print(c,a,b)
Buggy code:
arr = map(int, input().split())
print(arr[2], arr[0], arr[1])

Fixed code:
arr = list(map(int, input().split()))
print(arr[2], arr[0], arr[1])
Buggy code:
A = list(map(int,input().split()))

print(A[2], A[1], A[0])

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

print(A[2], A[0], A[1])
Buggy code:
a,b,c = list(map(int, input(),split()))
print(c,a,b)

Fixed code:
a,b,c = list(map(int, input().split()))
print(c,a,b)
Buggy code:
X,Y,Z = map(int,input().split)
X,Y,Z = Z,X,Y
print(X,Y,Z)

Fixed code:
X,Y,Z=map(int, input().split()) 
print(Z,X,Y)
Buggy code:
X, Y, Z = map(int, input().split())

"""
temp = Y
Y = X
X = temp

temp = Z
Z = X
X = temp
"""
print(Z, Y, X)

Fixed code:
X, Y, Z = map(int, input().split())

"""
temp = Y
Y = X
X = temp

temp = Z
Z = X
X = temp
"""

print(Z, X, Y)
Buggy code:
ri = lambda S: [int(v) for v in S.split()]
X, Y, Z = ri(input())

if X > Y:
    X, Y = Y, X
if Y > Z:
    Y, Z = Z, Y
if X > Y:
    X, Y = Y, X

print(X, Y, Z, sep=" ")

Fixed code:
ri = lambda S: [int(v) for v in S.split()]
X, Y, Z = ri(input())

X, Y = Y, X
X, Z = Z, X

print(X, Y, Z, sep=" ")
Buggy code:
nums = [int(e) for e in input().split]
a = nums[0]
nums[0] = nums[2]
nums[2] = a
print(str(nums[0]) + ' ' + str(nums[1]) + ' ' + str(nums[2]))

Fixed code:
nums = [int(e) for e in input().split()]
a = nums[0]
nums[0] = nums[1]
nums[1] = a
a=nums[0]
nums[0] = nums[2]
nums[2] = a
print(str(nums[0]) + ' ' + str(nums[1]) + ' ' + str(nums[2]))
Buggy code:
x,y,z = map(int,input().split())
print(z,y,x)

Fixed code:
x,y,z=map(int,input().split())
x,y=y,x
x,z=z,x






print(x,y,z)
Buggy code:
x,y,z = map(int,input().split())
print('{} {} {}').format(z,x,y)

Fixed code:
x, y, z = map(int, input().split())
print("{} {} {}".format(z,x,y))
Buggy code:
A, B, C = list(map(int, input().split()))

A, B = B, A
A, C = C, A
print(A, B, C)A, B, C = list(map(int, input().split()))

A, B = B, A
A, C = C, A
print(A, B, C)

Fixed code:
A, B, C = list(map(int, input().split()))

A, B = B, A
A, C = C, A
print(A, B, C)
Buggy code:
input_list = input().split()
a = int(input_list[2])
b = int(input_list[0])
c = int(input_list[1])
print("{} {} {}".format(a, b, c)

Fixed code:
input_list = input().split()
a = int(input_list[2])
b = int(input_list[0])
c = int(input_list[1])
print("{} {} {}".format(a, b, c))
Buggy code:
x,y,z = map(int,input().split())

x,y = y,z
x,z = z,x
print(x,y,z)


Fixed code:
x, y, z = tuple(map(int, input().split()))

print(z, x, y)
Buggy code:
import sys
a, b, c = int(sys.stdin.readline().split())

print(c, a, b)

Fixed code:
import sys
a, b, c = map(int, sys.stdin.readline().split())

print(c, a, b)
Buggy code:
x,y,z=list(map(int,input().split()))
print(x,y,z)


Fixed code:
x,y,z=list(map(int,input().split()))
print(z,x,y)
Buggy code:
x = list(map(int,input().split()))
copy = x[0]
x[0] = x[1]
x[1] = copy
print(x)

copy = x[0]
x[0] = x[2]
x[2] = copy

print(" ".join([str(i) for i in x]))

Fixed code:
x = list(map(int,input().split()))
copy = x[0]
x[0] = x[1]
x[1] = copy

copy = x[0]
x[0] = x[2]
x[2] = copy

print(" ".join([str(i) for i in x]))
Buggy code:
x, y, z = map(int, input().split())

x, y = x, y
x, z = z, x 

print(x, y ,z)

Fixed code:
x, y, z = map(int, input().split())

x, y = y, x
x, z = z, x

print(x, y ,z)
Buggy code:
a = list(map(int, input().split()))
b = [0, 0, 0]

b[0] = a[2]
b[1] = a[0]
b[2] = a[1]
print(b)

B = [str(a) for a in b]
B = " ".join(B)
print(B)

Fixed code:
a = list(map(int, input().split()))
b = [0, 0, 0]
b[0] = a[2]
b[1] = a[0]
b[2] = a[1]
# print(b)

B = [str(a) for a in b]
B = " ".join(B)
print(B)
Buggy code:
a,b,c=map(int,input().split())
print("{}{}{}".format(c,a,b))

Fixed code:
a,b,c=map(int,input().split())
print("{} {} {}".format(c,a,b))
Buggy code:
a,b,c=map(int,input().split())
print(b)
print(c)
print(a)

Fixed code:
a,b,c=list(map(int, input().split()))
a, b = b, a
a, c = c, a
print(a,b,c)
Buggy code:
x, y, z = map(int, input().split())
print(c, a, b)

Fixed code:
x,y,z = map(int,input().split())

a,b,c = x,y,z
a,b = b,a
a,c = c,a

print(a,b,c)
Buggy code:
x,y,z=map(int,input().split())

print(z,y,x)

Fixed code:
x,y,z = map(int,input().split())
x,y = y,x
x,z = z,x
print(x,y,z)
Buggy code:
a = [int(i) for i in input().split()]
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
print(a)

Fixed code:
a = [int(i) for i in input().split()]
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
print(a[0], a[1], a[2])
Buggy code:
a, b, c = map(int, input().split())
print("{} {} {}".format(c, b, a))

Fixed code:
a, b, c = map(int, input().split())
tmp = a
a = b
b = tmp
tmp = c
c = a
a = tmp
print("{} {} {}".format(a, b, c))
Buggy code:
a,b,c = int(input().split())
a,b,c = c,a,b
print(a,b,c)

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

Fixed code:
a,b,c = map(int,input().split())
a,c = c,a
b,c = c,b
print(a,b,c)
Buggy code:
A,B,C = map(int, input().split())

A,C = C,A

print(A,B,C)

Fixed code:
A,B,C=map(int,input().split())

A,B = B,A
A,C = C,A
print(A,B,C)
Buggy code:
X,Y,Z=map(int,input().split())

print(Y,Z,X)

Fixed code:
X,Y,Z = map(int, input().split())
tmp = Y
Y = X
X = Z
Z = tmp
print(X,Y,Z)
Buggy code:
a = list(map(int, input().split()))
a[0] = a[1]
a[0] = a[2]
print(a[0],a[1],a[2], sep=' ')

Fixed code:
a = list(map(int, input().split()))
k = a[0]
a[0] = a[1]
a[1] = k
k = a[0]
a[0] = a[2]
a[2] = k
print(a[0], a[1], a[2], sep=' ')
Buggy code:
x,y,z = map(int,input().split())
print(y,z,x)

Fixed code:
x,y,z = list(map(int,input().split()))
x,y = y,x
x,z = z,x
print(x,y,z)
Buggy code:
a,b,c = map(int,input().split())

print("{} {} {}".format(c,b,a))

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

print("{} {} {}".format(c,a,b))
Buggy code:
A,B,C = map= (int, input().split())
print(C,A,B)

Fixed code:
A,B,C= map(int,input().split())
print(C,A,B)
Buggy code:
X,Y,Z=map(int,input().split())
A=[Z,Y,X]
print(*A)

Fixed code:
X,Y,Z=map(int,input().split())
A=[Z,X,Y]
print(*A)
Buggy code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    x, y, z = map(int, rl().sprit())
    print(z, x, y)
    

if __name__ == '__main__':
    solve()


Fixed code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    x, y, z = map(int, rl().split())
    print(z, x, y)
    

if __name__ == '__main__':
    solve()
Buggy code:
a,b,c = list(map(int,input().split()))

print(c,b,a)


Fixed code:
a,b,c=map(int,input().split())
a,b,c=c,a,b
print(a,b,c)
Buggy code:
a = list(map(int,input().split()))
a[0],a[1],a[2] = a[2], a[0] ,a[1]
print(a)

Fixed code:
a = list(map(int,input().split()))
a[0],a[1],a[2] = a[2], a[0], a[1]
print(*a)
Buggy code:
A,B,C=list(map(int,input().split()))
A,B,C=B,C,A
print(A,B,C)

Fixed code:
A,B,C=map(int,input().split())
print(C,A,B)
Buggy code:
x,y,z=map(int, input().split())
print(z,y,x)

Fixed code:
x,y,z = list(map(int, input().split()))

print(z,x,y)
Buggy code:
x,y,z=map(int,input().split())
t=x
x=y
y=t
t=x
x=z
z=t
print(x,y,z,sep="")


Fixed code:
x,y,z=map(int,input().split())
t=x
x=y
y=t
t=x
x=z
z=t
print(x,y,z,sep=" ")
Buggy code:
X,Y,Z=map(int,input().split())
print(Y Z X)

Fixed code:
X,Y,Z = map(int,input().split())
print(Z, X ,Y)
Buggy code:
# A
A, B, C = map(int,input().split())
print(C, B, A)

Fixed code:
# A
A, B, C = map(int,input().split())
print(C, A, B)
Buggy code:
x,y,z = map(input().split())
print(z,x,y)

Fixed code:
x,y,z = map(int,input().split())
x,y = y,x
x,z = z,x
print(x,y,z)
Buggy code:
a, b, c = map(int, input().split())
a = b
a = c
print(a b c)

Fixed code:
a,b,c= map(int,input().split(' '))
a,b=b,a
a,c= c,a
print(a,b,c)
Buggy code:
def resolve():
    a, b, c = map(int, input().split())
    a, b = b, a
    a, c = c, a
    return print(a, b, c)


if __name__ == "__main__":
    resolve

Fixed code:

def resolve():
    a, b, c = map(int, input().split())
    a, b = b, a
    a, c = c, a
    return print(a, b, c)


if __name__ == "__main__":
    resolve()
Buggy code:
X, Y, Z = map(int, input().split())

x = str(X)
y = str(Y)
z = str(Z)
print(Z + " " + X + " " + Y)

Fixed code:
X, Y, Z = map(int, input().split())

x = str(X)
y = str(Y)
z = str(Z)
print(z + " " + x + " " + y)
Buggy code:
Z,X,Y =int(input().split())
print(X,Y,Z)

Fixed code:
Y, Z, X =map(int, input().split())
print(X,Y,Z)
Buggy code:
x,y.z=map(int,input().split())
print(z,x,y)

Fixed code:
x,y,z= list(map(int, input().split()))
print(z,x,y)
Buggy code:
A, B, C = map(int, input().split())
print(B, C, A)

Fixed code:
A, B, C = map(int, input().split())

A, B = B, A
A, C = C, A

print(A,B,C)
Buggy code:
a,b,c = map(int,input(),split())
print(c,a,b)

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

print(c, b ,a)

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

print(c, a ,b)
Buggy code:
    x, y ,z = map(int, input().split())
    x, y, z = y,x,z
    y,x,z = z,x,y
    print(y,x,z)


Fixed code:
x,y,z = map(int,input().split())

tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp

print(x,y,z)
Buggy code:
x,y,z=map(int,input().split())
li=[z,x,y]
print(" ".join(li))

Fixed code:
x,y,z=map(int,input().split())
li=[z,x,y]
print(" ".join(map(str,li)))
Buggy code:
X, Y, Z = map(int, input().split())
tmp = X
X = Y
Y = tmp
tmp2 = X
Z = tmp2
X = Z
print(X,Y,Z)

Fixed code:
X, Y, Z = map(int, input().split())
tmp = X
X = Y
Y = tmp
tmp2 = X
X = Z
Z = tmp2

print(X,Y,Z)
Buggy code:
def main():
    N = [int(_) for _ in input().split()]
    tmpA = N[0]
    tmpB = N[0]
    tmpC = N[0]
    print(N[2], N[1], N[0]) 



if __name__ == "__main__":
    main()


Fixed code:
def main():
    N = [int(_) for _ in input().split()]
    A = N[0]
    B = N[1]
    C = N[2]

    tmp = B
    B = A
    A = tmp

    tmp = C
    C = A
    A = tmp

    print(A, B ,C)

if __name__ == "__main__":
    main()
Buggy code:
X,Y,Z = map(int,input().split())
X,Y,Z = Y,X,Z
X,Y,Z = Z,Y,X

print('X,Y,Z')

Fixed code:
X, Y, Z = map(int, input().split())
X, Y, Z = Y, X, Z
X, Y, Z = Z, Y, X
print(X, Y, Z)
Buggy code:
A,B,C=X,Y,Z=map(int,input().split())

A = Y
B = X
A = Z
C = X

print(str(A)+' '+str(B)+' '+str(C))

Fixed code:
X,Y,Z=map(int,input().split())
A,B,C=X,Y,Z
 
A = Y
B = X
A = Z
C = Y
 
print(str(A)+' '+str(B)+' '+str(C))
Buggy code:
l = list(map(int,input().split()))
print(l[2]+' 'l[0]+' 'l[1])

Fixed code:
l = list(map(int,input().split()))
print(str(l[2])+' '+str(l[0])+' '+str(l[1]))
Buggy code:

x,y,z=map(int,input().split())
print(z,y,x)

Fixed code:

x,y,z=map(int,input().split())
print(z,x,y)
Buggy code:
X, Y, Z = map(int, input().split())
tmp = 0;

tmp = X
X = Y
Y = Z
Z = tmp

print(X, Y, Z)


Fixed code:
X, Y, Z = map(int, input().split())
tmp = 0;

tmp = X
X = Z
Z = Y
Y = tmp

print(X, Y, Z)
Buggy code:
i,j,k = list(map(int , input().split()))
print(j,k,i)


Fixed code:
i,j,k = list(map(int , input().split()))
print(k,i,j)
Buggy code:
a, b, c = map(int, input().split())
print(c, b, a)

Fixed code:
a, b, c = map(int, input().split())
a, b = b, a
a, c = c, a
print(a, b, c)
Buggy code:
X,Y,Z=int(input().split())

print(Z,X,Y)

Fixed code:
X,Y,Z=map(int, input().split())

print(Z,X,Y)
Buggy code:
x,y,z = map(int,input().split())
l = []

l.append(z)
l.append(x)
l.append(y)

print(l)


Fixed code:
x,y,z = map(int,input().split())
l = []

l.append(z)
l.append(x)
l.append(y)

print(*l)
Buggy code:
a,b,c = map(int, input().strip())
print(c,a,b)

Fixed code:
a,b,c = map(int, input().strip().split())
print(c,a,b)
Buggy code:
# coding: utf-8
boxes = list(map(int, input().split()))
tmp_a, tmp_b = boxes[1], boxes[0]
boxes[0], boxes[1] = tmp_a, tmp_b
tmp_a, tmp_c = boxes[2], boxes[0]
boxes[0], boxes[2] = tmp_a, tmp_c
print(boxes)

Fixed code:
# coding: utf-8
boxes = list(map(int, input().split()))
tmp_a, tmp_b = boxes[1], boxes[0]
boxes[0], boxes[1] = tmp_a, tmp_b
tmp_a, tmp_c = boxes[2], boxes[0]
boxes[0], boxes[2] = tmp_a, tmp_c
print(boxes[0], boxes[1], boxes[2])
Buggy code:
x, y, z = map(int, input().split())
print(int(z, x, y))

Fixed code:
x, y, z = map(int, input().split())
 
x, y, z = y, z, x
print(y, z, x)
Buggy code:
x,y,z = map(int,input().split())
print(z x y)

Fixed code:
x,y,z = map(int, input().split())
temp = y
y = x
x = z
z = temp
print(x,y,z)
Buggy code:
x, y, z = map(int, input().split(" "))
print(y, x, z)

Fixed code:
x, y, z = map(int, input().split(" "))
print(z, x, y)
Buggy code:
for _ in range(1):
	a,b,c = map(int,input().split())
    print(c,a,b)


Fixed code:
for _ in range(1):
	a,b,c = map(int,input().split())
	print(c,a,b)
Buggy code:
X, Y, Z = map(int, input().split())
 
print(Z+" "+X+" "+Y)

Fixed code:
X, Y, Z = map(int, input().split())
print(str(Z)+' '+str(X)+' '+str(Y))
Buggy code:
x,y,z= map(int, input().split())

print(z x y)

Fixed code:
x, y, z  = list(map(int, input().split()))
print(z, x, y)
Buggy code:
from sys import stdin

a,b,c=map(int,input().split())
print(str(c)+" "+str(a)+" "str(c))

Fixed code:
from sys import stdin

a,b,c=map(int,input().split())
print(str(c)+" "+str(a)+" "+str(b))
Buggy code:
a,b,c = map(int, input().split())
print(c,a,b)v

Fixed code:
a,b,c=map(int,input().split())
a,b=b,a
a,c=c,a
print(a, b, c)
Buggy code:
x,y,z=map(int, input().split)
print("{} {} {}".format(z,x,y))

Fixed code:
x,y,z=map(int, input().split())
print("{} {} {}".format(z,x,y))
Buggy code:
num = list(map(int, input().split()))

num.reverse()

print(num[0], num[1], num[2])

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

print(num[2], num[0], num[1])
Buggy code:
a = list(map(int,input().split()))
n = len(a)-1
i = 0
for _ in range(len(a)-1):
    temp = a[i]
    a[i] = a[n-1]
    a[n-1] = temp
    n+=1
print(a)

Fixed code:
a = list(map(int,input().split()))
n = len(a)-1
i = 0
for _ in range(len(a)-1):
    temp = a[i]
    a[i] = a[n-1]
    a[n-1] = temp
    n+=1
for  i in a:
         print(i,end=" ")
Buggy code:
A,B,C = map(int,input(),split())
print(C,A,B)

Fixed code:
A,B,C=map(int, input().split())
A,B=B,A
A,C=C,A
print(A,B,C)
Buggy code:
x, y, z = (int(i) for i in input().split())

print('f{z} {x} {y}')


Fixed code:
x, y, z = (int(i) for i in input().split())

print(f'{z} {x} {y}')
Buggy code:
a,b,c = map(int,input().split())
print(c,b,a)


Fixed code:
a,b,c=map(int,input().split())    
print(c,a,b)
Buggy code:
X,Y,Z=map(int(input().split()))
print(Z,X,Y)

Fixed code:
X, Y, Z = map(int, input().split(' '))
print(Z,X,Y)
Buggy code:
x,y,z = map(int,input().split(' '))
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp

Fixed code:
x,y,z = map(int,input().split(' '))
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x,y,z)
Buggy code:

x , y , z = map(int,input().split())
print('{} {} {}'.format(z,y,x))

Fixed code:

x , y , z = map(int,input().split())
print('{} {} {}'.format(z,x,y))
Buggy code:
X,Y,Z=list(map(int, input().split()))
print(str(Z)+str(X)+str(Y))

Fixed code:
X,Y,Z=list(map(int, input().split()))
print(str(Z)+' '+str(X)+' '+str(Y))
Buggy code:
 a, b,c = map(int, input().split())
  print(a,b,c)

Fixed code:
a,b,c = map(int,input().split())
a,b = b,a
a,c = c,a
print(a, b ,c)
Buggy code:
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

x,y,z = l_in()
print(y,z,x)


Fixed code:
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

x,y,z = l_in()
print(z,x,y)
Buggy code:
a,b,c = int(input().split())
a,b = b,a
a,c = c,a
print(a,b,c)

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

a,b = b,a
a,c = c,a

print(a,b,c)
Buggy code:
N,K = map(int,input().split())



if N>=K:
    x = N%K
    print(min(x,abs(K-x))
else:
          N<K
          print(min(N,abs(K-N))

Fixed code:
N,K = map(int,input().split())

if N>=K:
    x = N%K
    print(min(x,abs(K-x)))
else:
    print(min(N,abs(K-N)))
Buggy code:
N, K = [int(i) for i in input().split(' ')]

def res():
  if N == K:
    return 0
  elif N > K:
    return N % K if N - (N % K) > (N % K) else N - (N % K)
  else :
    return N

print(res())

Fixed code:
N, K = [int(i) for i in input().split(' ')]

def res():
  if N == K:
    return 0
  elif N > K:
    return N % K if K - (N % K) > (N % K) else K - (N % K)
  else :
    return abs(N - K) if abs(N - K) < abs(abs(N-K) - K) else abs(abs(N-K) - K)

print(res())
Buggy code:
N, K = map(int, input().split())

while(True):
    if(N <= abs(N-K)):
        print(N)
        break
    else:
        N = abs(N-K)


Fixed code:
N, K = map(int, input().split())

N = N%K
while(True):
    if(N <= abs(N-K)):
        print(N)
        break
    else:
        N = abs(N-K)