Problem:
 Score : 100 points    Problem Statement  We have three boxes A , B , and C , each of which contains an integer. Currently, the boxes A , B , and C contain the integers X , Y , and Z , respectively. We will now do the operations below in order. Find the content of each box afterward.   Swap the contents of the boxes A and B  Swap the contents of the boxes A and C       Constraints   1 \leq X,Y,Z \leq 100  All values in input are integers.         Input  Input is given from Standard Input in the following format:  X  Y  Z       Output  Print the integers contained in the boxes A , B , and C , in this order, with space in between.        Sample Input 1 1 2 3      Sample Output 1 3 1 2  After the contents of the boxes A and B are swapped, A , B , and C contain 2 , 1 , and 3 , respectively. Then, after the contents of A and C are swapped, A , B , and C contain 3 , 1 , and 2 , respectively.       Sample Input 2 100 100 100      Sample Output 2 100 100 100       Sample Input 3 41 59 31      Sample Output 3 31 41 59

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

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

print(Z,X,Y)

Solution (Python):
x,y,z = input().split()
print(z + ' ' + x + ' ' + y)

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

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

print(X,Y,Z)

Solution (Python):
X,Y,Z = map(int,input().split())
A,B,C = X,Y,Z
A,B = B,A
A,C = C,A
print('{} {} {}'.format(A,B,C))

Solution (Python):
def main():
  a,b,c = list(map(int,input().split()))
  tmp=a
  a=b
  b=tmp
  tmp=a
  a=c
  c=tmp
  print(a,b,c)

main()

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

Solution (Python):
try:
    X_s,Y_s,Z_s = input().split(' ')
    X=int(X_s)
    Y=int(Y_s)
    Z=int(Z_s)
    
    if X>=1 and X<=100 and Y>=1 and Y<=100 and Z>=1 and Z<=100:
        
        A=X
        B=Y
        C=Z
        
        temp=B
        B=A
        A=temp
        
        temp=C
        C=A
        A=temp
        
        print(A,'',B,'',C)
        
except Exception as e:
    print(e)

Solution (Python):
X, Y, Z = map(int, input().split())
print("{} {} {}".format(Z, X, Y))

Solution (Python):
x,y,z = input().split()
print(z,x,y)

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

tmp = A
A = B
B = tmp
tmp = A
A = C
C = tmp

print(A + " " + B + " " + C)

Solution (Python):
n = input().split()

print( n[2] +' '+ n[0] + ' ' +  n[1])

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

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

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

Solution (Python):
a, b, c = input().split()
print(c,a,b)

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

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

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

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

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

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

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

ans = (" ").join([a, b, c])
print(ans)

Solution (Python):
x, y, z = input().split()
print(z, x, y)

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

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

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

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

Solution (Python):
x,y,z=map(str, input().split())
print(z,x,y)

Solution (Python):
X, Y, Z = [int(i) for i in input().split()]
temp = int()
temp = Y
Y = X
X= temp
temp = Z
Z = X
X = temp
print(X, Y, Z)

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

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

print(z,x,y)

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

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

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

print(z,x,y)

Solution (Python):
x, y, z = [int(i) for i in input().split()]
print(z, x, y)

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

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

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

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

Solution (Python):
X,Y,Z = map(int,input().split())
G = X
X = Y
Y = G
G = X
X = Z
Z = G
print(f'{X} {Y} {Z}')

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

print(z,x,y)

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

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

boxes[0], boxes[1] = boxes[1], boxes[0]
boxes[0], boxes[2] = boxes[2], boxes[0]

print(str(boxes[0]) + ' ' + str(boxes[1]) + ' ' + str(boxes[2]))

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

Solution (Python):
X,Y,Z = map(int,input().split())
X,Y = Y,X
X,Z = Z,X
print(X,Y,Z,sep=" ")

Solution (Python):
def resolve():
    x, y, z = list(map(int, input().split()))

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

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

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

print(z, x, y)

Solution (Python):
(x,y,z) = input().split(' ')
print(' '.join((z,x,y)))

Solution (Python):
*a, = map(int,input().split())
print("{} {} {}".format(a[2],a[0],a[1]))

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

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

Solution (Python):

list = input().split()
 

list[0], list[1] = list[1], list[0]
 

list[0], list[2] = list[2], list[0]    
              
print(' '.join(list))

Solution (Python):

list = input().split()


temp = list[0]
list[0] = list[1]
list[1] = temp


temp = list[0]
list[0] = list[2]
list[2] = temp              
              
print(' '.join(list))

Solution (Python):
a, b, c = map(int, input().split())
k = a
a = b
b = k
i = a
a = c
c = i
print(a, b, c)

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

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

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

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

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

print(z,x,y)

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

print(c,a,b)

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

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

Solution (Python):
a = list(map(int,input().split()))
a[0],a[1]=a[1],a[0]
a[0],a[2]=a[2],a[0]
print(*a)

Solution (Python):
combined = input().split(" ")
a = combined[0]
b = combined[1]
c = combined[2]

temp1 = b
b = a
a = temp1

temp2 = c
c = a
a = temp2

print(a, b, c)

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

Solution (Python):
import sys

input = lambda: sys.stdin.readline().rstrip()


def solve():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


if __name__ == '__main__':
    solve()

Solution (Python):
x, y, z = map(int, input().split())
print("{0} {1} {2}".format(z, x, y))

Solution (Python):
x, y, z = map(int, input().split())
tmp = 0

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

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

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

A,B,C = Z,X,Y

print(A,B,C)

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

Solution (Python):
X, Y, Z = input().split()
print(Z, X, Y)

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

Solution (Python):

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

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

print(A,B,C)

Solution (Python):
A,B,C = map(int, input().split())
print('{} {} {}'.format(C,A,B))

Solution (Python):
x = input().split()
x[0], x[1], x[2] = x[2], x[0], x[1]
print(x[0]+' '+x[1]+' '+x[2])

Solution (Python):
x,y,z=map(int,input().strip().split(' ')) 
print(z,x,y)

Solution (Python):
x, y, z = map(int, input().split())
print(f"{z} {x} {y}")

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

Solution (Python):
x, y, z = map(int, input().split())
print(*[z, x, y], sep=' ')

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

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

Solution (Python):
x,y,z=map(int,input().split())
print("{} {} {}".format(z,x,y))

Solution (Python):
X, Y, Z = list(map(str, input().split()))

print(Z + " " + X + " " + Y)

Solution (Python):
x, y, z = map(int, input().split())
print("{0} {1} {2}".format(z, x, y))

Solution (Python):
x,y,z = map(str, input().split())
print( z + " " + x + " " + y)

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

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

tmp = x
x = y
y = tmp

tmo = x
x = z
z = tmo

print(x, y, z)

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


print(c,a,b)

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


print(c,a,b)

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

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

Solution (Python):
import sys


if __name__ == '__main__':
    a, b, c = map(int, input().split())
    print(c, a, b)

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

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

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

Solution (Python):
l = input().split()
print(l[2], l[0], l[1])

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

X, Y, Z = lr()
print(Z, X, Y)

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

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

print(Z,X,Y)

Solution (Python):
x,y,z= map(str, input().split())

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

Solution (Python):
x,y,z = map(int,input().split())
temp = x
x = y
y = temp
temp = x
x = z
z = temp
print(x,y,z)

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

Solution (Python):
a,b,c=input().split()
print(c,a,b)

Solution (Python):
a,b,c=input().split()
print(c,a,b)

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

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

print(Z,X,Y)

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

print(Z, X, Y)

Solution (Python):
def A():
    x,y,z = list(map(str, input().split()))
    print(z+" "+x+" "+y)
A()

Solution (Python):
N=input().split()
X=N[0]
Y=N[1]
Z=N[2]

print(Z + ' ' + X + ' ' + Y)

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

print(z, x, y)

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

Solution (Python):
X,Y,Z = map(int,input().split())
print("{} {} {}".format(Z,X,Y))

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

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

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

print(z, x, y)

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

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

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


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

Solution (Python):

X, Y, Z = [int(_) for _ in input().split()]
print(Z, X, Y)

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

print(Z,X,Y)

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

print(Z, X, Y)

Solution (Python):
x,y,z=map(int,input().split())
li=[z,x,y]
print(" ".join(map(str,li)))

Solution (Python):
s=input().split()
a=s[0]
b=s[1]
c=s[2]
a,b,c=c,a,b
print(a,b,c)

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

Solution (Python):
list = input().split()
print(list[2],list[0],list[1])

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

p=x
x=y
y=p

p=x
x=z
z=p

print('%s %s %s' %(x,y,z))

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  
 
x, y, z = na()
print(z, x, y)

Solution (Python):
X, Y, Z = map(int, input().split())
A = X
B = Y
C = Z
A = Z
B = X
C = Y

print(int(A), int(B), int(C))

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

A=[Z,X,Y]
print(*A,end='')

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

        print("{} {} {}".format(Z, X, Y))



if __name__=="__main__":
        main()

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

Solution (Python):
import sys
x,y,z=map(int, sys.stdin.readline().rstrip().split())
print(z, x, y)

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

print(Z + ' ' + X + ' ' + Y)

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

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

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

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

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

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

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

Solution (Python):
def main():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


if __name__ == '__main__':
    main()

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

print (C,A,B)

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    x, y, z = map(int, input().split())
    print(z, x, y)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
def solve_A():
    x, y, z = map(int, input().split())
    print("{0} {1} {2}".format(z, x, y))

solve_A()

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

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

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

Solution (Python):

x, y, z = [int(_) for _ in input().split()]
x, y = y, x
x, z = z, x
print(x, y, z)

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

print(str(Z)+" "+str(X)+" "+str(Y))

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

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

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

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

Solution (Python):
a = input().split()
print(a[2], a[0], a[1])

Solution (Python):
a,b,c = [int(x) for x in input().split(' ')]

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

Solution (Python):
X, Y, Z = input().split()
print(Z, X, Y)

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

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

a=x
b=y
c=z

tmp=0

tmp=b
b=a
a=tmp
tmp=c
c=a
a=tmp

print(a,b,c)

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

print(C, A, B)

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

print(C, A, B)

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

print(C, A, B)

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

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

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

Solution (Python):


def f(x, y, z):
    a, b, c = x, y, z
    a, b = b, a
    a, c = c, a
    print(a, b, c)

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

Solution (Python):
import sys
import heapq
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()


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

Solution (Python):
import sys
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
X,Y,Z = map(int, readline().split())
 
A,B,C = Z,X,Y
 
print(A,B,C)

Solution (Python):
x,y,z=input().split()
print(z,x,y)

Solution (Python):
def solve(string):
    x, y, z = map(int, string.split())
    return f"{z} {x} {y}"


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

Solution (Python):


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

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

d = int

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

Solution (Python):
def main():
    x, y, z = list(map(int, input().split()))
    print(z, x, y)

if __name__ == '__main__':
    main()

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

A = List[0]
B = List[1]
C = List[2]

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

Solution (Python):



import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf



import math

import bisect


if __name__ == '__main__':
    a, b, c = list(map(int, input().split()))
    a, b = b, a
    a, c = c, a
    print("{} {} {}".format(a, b, c))

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

Solution (Python):
if __name__ == "__main__":
    X, Y, Z = map(int, input().split())
    print(f"{Z} {X} {Y}")

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

Solution (Python):
def main():
    X,Y,Z = input().split()
    print(Z+" "+X+" "+Y)

main()

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

Solution (Python):
X,Y,Z = map(int,(input().split()))
temp=X
X=Y
Y=temp
temp=X
X=Z
Z=temp
print(str(X)+" "+str(Y)+" "+str(Z))

Solution (Python):
*s,c=input().split()
print(c,*s)

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

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

Solution (Python):
X, Y, Z = input().split()
print(Z, X, Y)

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

tmp = xyz[0]
xyz[0] = xyz[1]
xyz[1] = tmp

tmp = xyz[0]
xyz[0] = xyz[2]
xyz[2] = tmp

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

Solution (Python):
list1 = list(map(int, input().split()))
list2= []
list2.append(list1[2])
list2.append(list1[0])
list2.append(list1[1])
print(list2[0], list2[1], list2[2])

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

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

print(z,x,y)

Solution (Python):
x,y,z=map(int,input().split())
print(z,x,y,sep=' ')

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

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

print(c,a,b)

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

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

print(z,x,y)

Solution (Python):
X, Y, Z = map(int,input().split())
A = X
B = Y
C = Z

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

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

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

print(z, x, y)

Solution (Python):
X, Y, Z = [int(x) for x in input().split()]

print(Z, X, Y)

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

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

print(X,Y,Z)

Solution (Python):
x, y, z = input().split()
print(' '.join([z, x, y]))

Solution (Python):
x, y, z = map(int, input().split())
print(str(z)+" "+str(x)+" "+str(y))

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

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

Solution (Python):
X, Y, Z = map(int, input().split())
print(*[Z, X, Y])

Solution (Python):
n=list(input().split())
print(n[2], n[0], n[1])

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

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

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

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

w = x
x = y
y = w
w = x
x = z
z = w

print(x,y,z)

Solution (Python):
x, y, z = [int(_) for _ in input().split()]
print(z, x, y)

Solution (Python):
import itertools
import math
import fractions
import functools
x, y, z = map(int, input().split())
print(z,x,y)

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

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

Solution (Python):
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

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



print(Z, X, Y)

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

Solution (Python):
values = input().split(' ')
print(' '.join((values[2], values[0], values[1])))

Solution (Python):
a,b,c = map(int, input().split())
a,b,c = c,a,b
print("{} {} {}".format(a,b,c))

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

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

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

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

print(x, y, z)

Solution (Python):
a,b,c=list(input().split())
print(c,  a,  b)

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

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

print(x,y,z)

Solution (Python):
X, Y, Z = map(str, input().split())
print(' '.join([Z, X, Y]))

Solution (Python):
from sys import stdin

X, Y, Z = stdin.readline().rstrip().split()
X, Y, Z = Z, X, Y
print(X, Y, Z)

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

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

def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return a,b
x,y = swap(x,y)
x,z = swap(x,z)
print(x,y,z)

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

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

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

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

print(A,B,C)

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

a,b = b,a

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

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

print(z,x, y)

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

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

print(Z,X,Y)

Solution (Python):
x,y,z=map(int,input().split())
result=str(z)+' '+str(x)+' '+str(y)
print(result)

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

Solution (Python):
a,b,c=input().split()
print(c+" "+a+" "+b)

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

print(X,Y,Z)

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

Solution (Python):
X, Y, Z=(int(x) for x in input().split())
print(Z, X, Y)

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

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

Solution (Python):
def ABC_161_A():
    X,Y,Z = map(int, input().split())
    A = Y
    B = X
    C = A
    A = Z

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


if __name__ == '__main__':

    ABC_161_A()

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

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

def main():
    X,Y,Z = map(int,input().split())
    print(Z,X,Y)

main()

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

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

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

Solution (Python):
a,b,c = input().split()
print(' '.join([c,a,b]))

Solution (Python):
X,Y,Z=input().split()
print(Z,X,Y)

Solution (Python):
X, Y, Z = map(int, input().split())
print("{} {} {}".format(Z, X, Y))

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

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

Solution (Python):
x,y,z=map(int,input().split())
print("{} {} {}".format(z,x,y))

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

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

print(C, A, B)

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

print(c,a,b)

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


a,b,c=map(int,readline().split())

print(c,a,b)

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

print("{} {} {}".format(z,x,y))

Solution (Python):
x, y, z = map(int, input().split())
tmp = 0
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x, y, z)

Solution (Python):
A, B, C = input().split()
print(C, A, B)

Solution (Python):
X, Y, Z = input().split()
print(Z, X, Y)

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

Solution (Python):
import sys










stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18



x,y,z = map(int, stdin.readline().rstrip().split())

print(z,x,y)

Solution (Python):
X, Y, Z = map(str,input().split())
print(Z, X, Y)

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

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

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

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


if __name__ == "__main__":
    main()

Solution (Python):
x,y,z = input().split()

print(z, x, y)

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

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

Solution (Python):
a,b,c=input().split()
print(c,a,b)

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

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

print(C + " " + A + " " + B)

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

Solution (Python):
val = input().split()
array = []
array.append(val[2])
array.append(val[0])
array.append(val[1])

print(' '.join(array))

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

print(z,x,y)

Solution (Python):
x,y,z=input().split()
print(z,x,y)

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

A = X
B = Y
C = Z

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

print(A,B,C)

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

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

Solution (Python):
line1 = input().split()
x = line1[0]
y = line1[1]
z = line1[2]
print(z, x, y)

Solution (Python):
def solve():
    x, y, z = map(int,input().split())
    print(z, x, y)


if __name__ == '__main__':
    solve()

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

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

print(z,x,y)

Solution (Python):
a = input().split()

print(int(a[2]),int(a[0]),int(a[1]))

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

print(z,x,y)

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

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

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

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

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

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

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

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

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

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

print(A, B, C)

Solution (Python):
import math
N = list(input().split())

N[0], N[1] = N[1], N[0]
N[0], N[2] = N[2], N[0]

print(' '.join(N))

Solution (Python):
A,B,C=map(int,input().split())
a=C
b=A
c=B
print(str(a)+" "+str(b)+" "+str(c))

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

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

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

Solution (Python):


X, Y, Z = map(int, input().split())
print(Z, X, Y)

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

Solution (Python):
x,y,z = map(int,input().split())
a = z
b = x
c = y
L = [a,b,c]
print(' '.join(map(str,L)))

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

print(z,x,y)

Solution (Python):
x, y, z = input().split()
print(z, x, y)

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

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

print(Z, X, Y)

Solution (Python):
a,b,c = input().split()
print(c,a,b)

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

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

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

print(z,x,y)

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

List=[X,Y,Z]

print(Z,X,Y)

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

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

print(X,Y,Z)

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

a = z
b = x
c = y

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

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

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

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

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

Solution (Python):
lis=list(map(int,list(input('').split(' '))))
print(str(lis[2])+" "+str(lis[0])+" "+str(lis[1]))

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

print(z,x,y)

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

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

Solution (Python):
print(*(lambda a, b, c: (c, a, b))(*input().split()))

Solution (Python):
print(*__import__("numpy").array(input().split(), dtype="i8")[[2, 0, 1]])

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

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

Solution (Python):
A, B, C = [int(i) for i in input().split()]

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

print("%s %s %s" % (A, B, C))

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

Solution (Python):



b, c, a = (int(i) for i in  input().split())
print(a, b, c)

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    a = LI()

    return JA(a[2:] + a[:2], " ")


print(main())

Solution (Python):
X,Y,Z=input().split()
print(Z,X,Y)

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

Solution (Python):
xyz = input().split(" ")
x = int(xyz[0])
y = int(xyz[1])
z = int(xyz[2])

print(z,x,y)

Solution (Python):
xyz = input().split(" ")

x = int(xyz[0])
y = int(xyz[1])
z = int(xyz[2])

print(z, x, y)

Solution (Python):
A,B,C=(int(x) for x in input().split())
print(C,A,B)

Solution (Python):
X, Y, Z = [int(_) for _ in input().split()]
print(Z, X, Y)