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):
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())
tmp = y
y = x
x = tmp

tmp2 = z
z = x
x = tmp2
print("{} {} {}".format(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=map(int,input().split())
a=x
b=y
c=z
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())
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,end=' ')
print(x,end=' ')
print(y,end='')

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):
def sep():
    return map(int,input().strip().split(" "))
def lis():
    return list(sep())
import sys
sys.setrecursionlimit(10**6)

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

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

def swap(a, b, c):
    i = 0
    i = a
    a = b
    b = i

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

swap(x,y,z)

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

def swap(a, b, c):
    i = 0
    i = a
    a = b
    b = i

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

swap(x,y,z)

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

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

print(x,y,z)

Solution (Python):
x,y,z = map(int,input().split())
print(z,end=' ')
print(x,end=' ')
print(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)
print(X)
print(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

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):
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=[int(s) for s in 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())
X,Y=Y,X
X,Z=Z,X
print(X,Y,Z)

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

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

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

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

Solution (Python):

X,Y,Z = list(map(int, input().split()))
print(('{} {} {}').format(str(Z), str(X), str(Y)))

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

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

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

print(Z, X, Y)

Solution (Python):
[A, B, C] = list(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, end='')
print(" ", end='')
print(x, end='')
print(" ", end='')
print(y, end='')

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

print(c, a, b)

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

print(x, y, z)

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

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

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

A = int(A)
B = int(B)
C = int(C)

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

print(A, B, C)

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

temp = c
c = b
b = a
a = temp
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(z,x,y)

Solution (Python):
def main():
    xyz = [int(_x) for _x in input().split()]
    print(xyz[2], xyz[0], xyz[1])


main()

Solution (Python):
a,b,c=(int(x) for x in 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(str, 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())

temp = Y
Y = X
X = temp

temp = Z
Z = X
X = temp

print ("{} {} {}".format(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())
a,b=b,a
a,c=c,a
print(a,b,c)

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

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

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

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(f"{z} {x} {y}")

if __name__ == "__main__":
    main()

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

print(l[2])
print(l[0])
print(l[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):
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):
import sys

X, Y, Z = map(int, sys.stdin.readline().split())
print(Z, X, Y)

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

Solution (Python):
X = input().split()
print(X[2], X[0], X[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):
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):
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())
a = int(y)
b = int(x)
c = int(y)
a = int(z)

print(a, b, 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())
X, Y = Y, X
X, Z = Z, X

print(X, Y, Z)

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

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

print(a,b,c)

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

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())
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):
XYZ = list(map(int, input().split()))
ABC = [0]*3
for i in range(3):
  ABC[i] = XYZ[(i+2)%3]
print(" ".join(map(str,ABC)))

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
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):
A,B,C = map(int,input().split())
print(C,A,B)

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 = 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):
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 = 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):
X, Y, Z = 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):










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

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):
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    X, Y, Z = input_nums()
    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())

print(z, x, y)

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

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

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

u = a
a = c
c = u

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

Solution (Python):
X,Y,Z=map(int,input().split())
print(f'{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())
temp = B
B = A
A = temp
temp = C
C = A
A = temp
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):
A, B, C = map(int, input().split())
print(str(C) + " " + str(A) + " " + str(B))

Solution (Python):
def main():
    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):
a,b,c=map(int,input().split())
a1=b
b1=a
a2=c
c1=a1
print(a2, b1, c1)

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,B,C = map (int, input ().split ())
print (C,A,B)

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

tmp2=A
A=C
C=tmp2

print(A,B,C)

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

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

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

if '__main__' == __name__:
    resolve()

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(str(z)+' '+str(x)+' '+str(y))

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

tempX = X
tempY = Y
tempZ = Z

X = tempZ
Y = tempX
Z = tempY

print(X,Y,Z)

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip.split())
def main():
    x,y,z = LI()
    print(z,x,y)
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):
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=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(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(z,x,y)

Solution (Python):



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

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))

x, y, z = inm()
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(" "))
tmp=Y
Y=X
X=tmp
tmp=Z
Z=X
X=tmp
print(X,Y,Z,end=" ")

Solution (Python):
N_List = list(map(int,input().split()))
N_List.insert(0,N_List.pop(2))
print(" ".join(map(str,N_List)))

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


def main():
    X, Y, Z = MI()
    A = [Z, X, Y]
    print(' '.join(map(str, A)))

if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    a,b,c=mi()
    a,b = b,a
    a,c = c,a

    print(a,b,c)



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):
x,y,z = map(int,input().split())
print(z,x,y)

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

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())
print(C, A, B)

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

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

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

Solution (Python):

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):
def main():
    s = list(map(int,input().strip().split()))
    tmp = s[0]
    s[0] = s[1]
    s[1] = tmp

    tmp = s[0]
    s[0] = s[2]
    s[2] = tmp

    print("{} {} {} ".format(s[0],s[1],s[2]))
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):
a = input().split()
print(a[2] + " " + a[0] + " " + a[1])

Solution (Python):
def solve():
    X,Y,Z = [int(i) for i in 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):
xyz = list(map(int,input().split()))

print("{} {} {}".format(xyz[2],xyz[0],xyz[1]))

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

tmp=x
x=y
y=tmp

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

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

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):
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 = input().split()
ans = ' '.join([C, A, B])
print(ans)

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

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





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):
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())
t=0
t=x;x=y;y=t;
t=x;x=z;z=t;
print(x,y,z)

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

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

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

lst = [z, x, y]
print(' '.join(lst))

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

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

Solution (Python):

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

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

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

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

print(Z,X,Y)

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

Solution (Python):


a,b,c = map(int, input().split())
print("{0} {1} {2}".format(c,a,b))

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


if __name__ == '__main__':
    main()

Solution (Python):
from os.path import split


def main():
    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):
ans = list(map(int,input().split()))
print(ans[2],ans[0],ans[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(Z,X,Y)

Solution (Python):
X, Y, Z = map(str, 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):
x, y, z = map(int, input().split())

print(z, x, y)

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

A = Y
B = X
C = Z

print(C, B, A)

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):
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):
import sys
s = sys.stdin.read().split()
print(s[2], s[0], s[1])

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

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

x,y,z = inpm()

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

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

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

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

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

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

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

Solution (Python):


def main():

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

    X, Y = change(X, Y)
    X, Z = change(X, Z)

    print(X, Y ,Z)

def change(a, b):
    num = a
    a = b
    b = num

    return(a, b)

if __name__ == "__main__":
    main()

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















































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    
    
    X, Y, Z = list(map(int, lines[0].split()))
    
    
    
    
    
    
    
    

    result = str(Z) + ' ' + str(X) + ' ' + str(Y)

    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['1 2 3']
        lines_export = ['3 1 2']
    if pattern == 2:
        lines_input = ['100 100 100']
        lines_export = ['100 100 100']
    if pattern == 3:
        lines_input = ['41 59 31']
        lines_export = ['31 41 59']
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

Solution (Python):




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

print (z,x,y)

Solution (Python):


from typing import *
import collections
import itertools
import math
import sys

INF = float('inf')


def solve(X: int, Y: int, Z: int):
    return f"{Z} {X} {Y}"


def main():

    sys.setrecursionlimit(10 ** 6)

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    Z = int(next(tokens))  
    print(f'{solve(X, Y, Z)}')


if __name__ == '__main__':
    main()

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

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

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

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

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

tmp = X
X = Y
Y = tmp

tmp = X
X = Z
Z = tmp

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

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

Solution (Python):
import sys
array = list(map(int,input().split()))
if not ( 1 <= min(array) and max(array) <= 100 ): sys.exit()
check = lambda x: isinstance(x,int)

print(array[2],array[0],array[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):
a,b,c = map(int, input().split())
print(c,a,b,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(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):
x,y,z=map(int,input().split())
print(z,x,y)

Solution (Python):
x,y,z = map(int, input().split())
x = x^y
y = x^y
x = x^y
x = z^x
z = z^x
x = z^x
print("{} {} {}".format(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())
temp = 0
temp = b
b = a
a = temp
temp = a
a = c
c = temp
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(int,input().split())
print(str(Z) + ' ' + str(X) + ' ' + str(Y))

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

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

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

print(c,a,b)

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

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

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

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

ABC_swap()

Solution (Python):


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

print(Z, X, Y)

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

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

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

print(f'{Z} {X} {Y}')

Solution (Python):
abc = input()
indiv = abc.split(" ")


temp = indiv[0]
indiv[0] = indiv[1]
indiv[1] = temp


temp = indiv[2]
indiv[2] = indiv[0]
indiv[0] = temp

print(indiv[0] + " " + indiv[1] + " " + indiv[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())
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)