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):
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 collections as cl


def II(): return int(sys.stdin.readline())


def MI(): return map(int, sys.stdin.readline().split())


def LI(): return list(map(int, sys.stdin.readline().split()))


def main():
    a, b, c = MI()
    print(c, a, b, sep=" ")


main()

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 = list(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):
a,b,c = map(int,input().split())

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

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

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

print(z,x,y)

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

Solution (Python):
import sys

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


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

    print(Z, X, Y)

    return


if __name__ == '__main__':
    main()

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

print(Z, X, Y)

Solution (Python):
def main():
 x,y,z = map(int,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=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 = [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):
a, b, c = map(int, input().split())
a, b = b, a
a, c = c, a
print(f'{a} {b} {c}')

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

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

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('{} {} {}'.format(z, x, y))

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

Solution (Python):
import sys


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


if __name__ == '__main__':
    main()

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):
x = list(input().split())
print(x[2] + " " + x[0] + " " + x[1])

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

print(z,x,y)

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())
x ^= y
y ^= x
x ^= y
x ^= z
z ^= x
x ^= z
print(x, y, z)

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

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

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

Solution (Python):
X, Y, Z = list(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):
A,B,C = map(int,input().split())
tmp = A
A = B
B = 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):
X,Y,Z = map(int,input().split())

print("{0} {1} {2}".format(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())
A,B=B,A
A,C=C,A
print(str(A)+" "+str(B)+" "+str(C))

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

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

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

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

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

print(x,y,z)

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

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

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

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

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

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

print(C, A, B)

Solution (Python):
A,B,C = map(str, input().split())
l = str(C)+str(' ')+str(A)+str(' ')+str(B)
print(l)

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

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

l[0],l[1]=l[1],l[0]
l[0],l[2]=l[2],l[0]

print(*l)

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

l[0],l[1]=l[1],l[0]
l[0],l[2]=l[2],l[0]

print(*l)

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

x[0],x[1] = x[1],x[0]
x[0],x[2] = x[2],x[0]

print(str(x[0]) +" " + str(x[1]) + " "+  str(x[2]))

Solution (Python):
xyz = input().split()
print(xyz[2]+ " " + xyz[0] + " " + xyz[1])

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

print(str(argList[2])+" "+str(argList[0])+" "+str(argList[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):
A,B,C = input().split()
print(C,A,B)

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

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

print(x, y, z)

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(" ".join(str(n) for n in XYZ))

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

Solution (Python):




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







print(b[-1], *b[:2])

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

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

Solution (Python):
a, b, c = input().split(' ')
print("{} {} {}".format(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("%d %d %d"%(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())
temp = X
X = Y
Y = temp
temp = X
X = Z
Z = temp
print(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):
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 = list(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):
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=y
b=x

a=z
c=y

print(a,b,c)

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

print(z,x,y)

Solution (Python):
import math  
from typing import Dict, List, Optional, Tuple, Union  


def main(A: List[int]):
    print(A[2], A[0], A[1])


if __name__ == "__main__":
    A = list(map(int, input().split()))
    main(A)

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

print(a, b, c)

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

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

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

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

print(*[ABC[i] for i in [2, 0, 1]])

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

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

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

W = Y
Y = X
X = W

A = Z
Z = X
X = A

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):
X, Y, Z = list(map(int,input().split()))
print(Z,X,Y)

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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


def main():
    solve()


if __name__ == '__main__':
    main()

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

    X, Y, Z = map(int, input().split())
    return " ".join(map(str, [Z, X, Y]))

if __name__ == '__main__':
    print(main())

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

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

print(z + " " + x + " " + y)

Solution (Python):
x,y,z = 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):
a, b, c = map(int, input().split())
print(str(c) + " " + str(a) + " " + str(b))

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(" ".join(map(str,a)))

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


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

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

print(x, y, z)

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

a[0],a[1] = a[1],a[0]
a[0],a[2] = a[2],a[0]

for i in range(3):
    print(a[i],end=' ');

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())
print(f'{c} {a} {b}')

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

Solution (Python):
X,Y,Z = (int(a) for a 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):
X,Y,Z=map(int,input().split())
print(Z,X,Y)

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

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

Solution (Python):
a, b, c = map(int, input().split())
tmp = a
a = b
b = tmp
tmp = a
a = c
c = 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):
s = input().split()

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

Solution (Python):
X, Y, Z = map(int, 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=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):
a = input().split()
print(a[2] +' ' +a[0]+' ' + a[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 = list(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())

ans=str(z)+' '+str(x)+' '+str(y)

print(ans)

Solution (Python):
a = [int(i) for i in input().split()]
print(a[2],a[0],a[1],sep=' ')

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

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

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 = 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())
print (c , a , b)

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

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

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

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

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

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

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


tmp=A
A=B
B=tmp


tmp=A
A=C
C=tmp

print(A,B,C)

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())
print(z,x,y,sep=" ")

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

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):
arr = list(map(int, input().split()))

a,b,c = arr[0], arr[1], arr[2]

print(c,a,b)

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

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

print(a,b,c)

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=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, end="")

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

Solution (Python):
def main():
  x, y, z = map(int, input().split())
  
  A = str(z)
  B = str(x)
  C = str(y)
  
  print(A + ' ' + B + ' ' + C)
      
  
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):
X, Y, Z = map(int, input().split())

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

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

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

def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return a,b


if __name__ == "__main__":
    main()

Solution (Python):


def swap(l, a, b, c):
    l[a], l[b] = l[b], l[a] 
    l[a], l[c] = l[c], l[a]
    return l

k = list(map(int, input().split()))
swap(k, 0, 1, 2)
for i in k:
    print(i, end  = " ")

Solution (Python):
a, b, c = map(int, 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):
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):
data=input()
x = data.split(" ")
tmp=x[2]
x[2]=x[1]
x[1]=x[0]
x[0]=tmp
print(x[0],x[1],x[2])

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

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

Solution (Python):



x,y,z=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):
L=list(map(int,input().split()))
L[2],L[0]=L[0],L[2]
L[1],L[2]=L[2],L[1]
print(*L)

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

print(z,x,y)

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(str, input().split())
print(z+' '+x+' '+y)

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

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

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

Solution (Python):
import numpy as np

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

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

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):
a=input()
a=a.split()
a=(a[2],a[0],a[1])
print(*a)

Solution (Python):
X,Y,Z = map(str,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 = 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 = 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 = 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(str,input().split())
a=[z,x,y]
print(' '.join(a))

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

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

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

Solution (Python):
x, y, z = 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())
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())
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=X
B=Y
C=Z
A,B=B,A
A,C=C,A
print(A,B,C)

Solution (Python):
import math
import sys
readline = sys.stdin.readline


def main():
    a, b, c = map(int, readline().rstrip().split())
    print(c, a, b)


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):
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):
def main():
    x, y, z = map(int, input().split())
    a = list([x, y, z])
    print(a[2], a[0], a[1], sep=' ')


if __name__=="__main__":
    main()

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

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 = list(map(str, input().split()))
print(Z+' '+X+' '+Y)

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

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

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

print(f"{c} {a} {b}")

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

Solution (Python):
X,Y,Z = (int(X) for X in input().split())
Y,X = X,Y
Z,X = X,Z
print('{} {} {}'.format(X,Y,Z))

Solution (Python):

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

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


import sys
input=sys.stdin.readline

def main():
    x,y,z=map(int,input().split())
    print(z,x,y)
    
    
    
if __name__=="__main__":
    main()

Solution (Python):
X,Y,Z=input().split()
N=[X,Y,Z]
print(N[2],N[0],N[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())
newx = z
newy = x
newz = y
print(newx,newy,newz)

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(str,input().split())
print(z+" "+x+" "+y)

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

Solution (Python):
X,Y,Z=input().split()
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):
a,b,c=map(int, input().split(" "))
print(c,a,b)

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

A,B,C=X,Y,Z
A,B,C=Z,X,Y
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())
print(z,x,y)

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):
A,B,C = list(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())
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())
temp=x
x=y
y=temp
temp=x
x=z
z=temp
print("{0} {1} {2}".format(x,y,z))

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

print(z, x, y)

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




c = x
x = y
y = c

c = x
x = z
z = c



print(x, y, z)

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

a = x
x = y
y = a

a = z
z = x
x = a

print(x,y,z)

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

Solution (Python):
import sys

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

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

print("%d %d %d" % (Z, X, Y))

Solution (Python):
box_A,box_B,box_C = map(int,input().split())

box_A,box_B = box_B,box_A
box_A,box_C = box_C,box_A
 
print(box_A,box_B,box_C)

Solution (Python):
x,y,z = map(int,input().split())
box_A = [x]
box_B = [y]
box_C = [z]

box_B.append(box_A.pop(0))
box_A.append(box_B.pop(0))
box_A.append(box_C.pop(0))
box_C.append(box_A.pop(0))
print(box_A[0],box_B[0],box_C[0])

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

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

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

answerList = [z, x, y]

for i in range(len(answerList)):
    print(answerList[i], end=' ')

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):
a,b,c = input().split()
print(c,a,b)

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

print(" ".join([C,A,B]))

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

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())
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('{} {} {}'.format(z, x, y))

Solution (Python):
input_lists = list(input().split(' '))
result = [input_lists[-1]]
result += input_lists[0:-1]
result = ' '.join(result)
print(result)

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

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

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

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

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

print(Z,X,Y)

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log, floor
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

x,y,z = MAP()

temp1 = x
x = y
y = temp1


temp2 = x
x = z
z = temp2

print(x,y,z)

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

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np

Mod = 1000000007
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    x, y, z = map(int, input().split())
    x, y = y, x
    x, z = z, x
    print(x,y,z)
if __name__ == "__main__":
    main()

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

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

print(str(x) + " " + str(y) + " " + str(z))

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

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)

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

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

tmp = a
a = b
b = tmp

tmp = a
a = c
c = tmp

print(f"{a} {b} {c}")

Solution (Python):
import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
input = sys.stdin.buffer.readline





def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))





def main():
	x,y,z=MI()
	print(z,x,y)





if __name__ == "__main__":
	main()

Solution (Python):
n = list(map(int, input().split()))
     
x, y = (n[1], n[0])
n[0], n[1] = (x, y)
     
x, z = (n[2], n[0])
n[0], n[2] = (x, z)
     
print(" ".join(list(map(str, n))))

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):
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,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(str(Z)+' '+str(X)+' '+str(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())
d = c
c = b
b = a
a = d
print(a,b,c)

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