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


import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    x, y, z = read_list(str)
    x, y = y, x
    x, z = z, x
    print("%s %s %s" % (x, y, z))


if __name__ == "__main__":
    main()

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

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

import sys


def solve(X: int, Y: int, Z: int):
    print(Z, X, Y)



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

if __name__ == '__main__':
    main()

Solution (Python):

from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

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


main()

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

print(C,A,B)

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

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

Solution (Python):
A,B,C = [int(n) for n in input().split()]
print(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):
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())
print("{} {} {}".format(z,x,y))

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

Solution (Python):
import sys
from copy import deepcopy
from collections import deque
sys.setrecursionlimit(10**6)

X, Y, Z = [int(n) for n in input().split(' ')]

print(Z, X, Y)

Solution (Python):

import heapq
from collections import defaultdict, deque
from math import ceil, factorial
from fractions import gcd
import sys
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9+7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
lmii = lambda: list(map(int, input().split()))
smii = lambda: sorted(map(int, input().split()))


x, y, z = mii()

print(z, x, y)

Solution (Python):
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.readline().strip()
def mdata(): return map(int, data().split())


mod=int(1e9+7)

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


if __name__ == '__main__':
    main()

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

a = z
b = x
c = y

print(a, b, c)

Solution (Python):
a,b,c = list(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):


import sys
import math
import time

import collections
from collections import deque
from collections import Counter
import queue
import copy
import bisect
import heapq








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

temp = A
A = B
B = 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=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(Z,X,Y)

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

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


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

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

tmp = X
X = Y
Y = tmp

tmp = X
X = Z
Z = tmp

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

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

print(z,x,y)

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

x, y, z = nm()
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 = [int(x) for x in input().split()]
print(Z, X, Y)

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

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

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

print(z, x, y)

Solution (Python):

import sys
import math
import numpy as np
import itertools



a, b, c = (int(i) for i in 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):
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(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())
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 = 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

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

    tmp = y
    y = x
    x = tmp

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

    return 0

if __name__ == '__main__':
    sys.exit(main())

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

print(z, x, y)

Solution (Python):
import sys
import numpy as np


x,y,z=map(int,sys.stdin.readline().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("{} {} {}".format(x, y, z))

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

print(z, x, y)

Solution (Python):

import collections
import itertools as it
import math
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):

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

print(C,A,B)

Solution (Python):
import numpy as np
import collections

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

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

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

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

Solution (Python):

x = [int(x) for x in input().split()]

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

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

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):
x,y,z=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):
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):
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

x,y,z = inm()
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):
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("{} {} {}".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):
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, m, h = map(int, input().split())

print(h, n, m)

Solution (Python):
import sys
input = sys.stdin.readline
from collections import Counter, deque

INF = float('inf')

""" Input
S = input()
N = int(input())
A = list(map(int, input().split()))
D = [int(input()) for _ in range(N)]
"""

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

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(str,input().split())
print(c+" "+a+" "+b)

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

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


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



if __name__ == "__main__":
    resolve()

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

print(C,A, B)

Solution (Python):

if __name__ == '__main__':
    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())
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(str(z)+" "+str(x)+" "+str(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())
X, Y, Z = Y, X, Z
X, Y, Z = Z, Y, X
print(X, Y, Z)

Solution (Python):
A, B, C = [int(e) for e in 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())

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

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

Solution (Python):

n, m ,l = map(int, open(0).read().split())
print('{} {} {}'.format(l, n, m))

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

Solution (Python):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *


def lcm(x, y):
    return (x * y) // math.gcd(x, y)


if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    print(str(a[2]) +" " + str(a[0])+" "+str(a[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 = map(int,input().split())

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

print(a,b,c)

Solution (Python):
InputIntList = lambda : list(map(int, input().split()))
InputStrList = lambda : list(input().split())


x, y, z = InputIntList()

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

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

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

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):
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
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read


x,y,z = [int(i) for i in read().split()]
x,y = y,x
x,z = z,x
print(x,y,z)

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

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

print(C,A,B)

Solution (Python):
x,y,z=[int(e) for e 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())

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)

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b,c = map(int,input().split(' '))
print(c,a,b)

Solution (Python):


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

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

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

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()
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):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

x,y,z = iim()
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):
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 = 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 = 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())
box = [c,a,b]
print(*box)

Solution (Python):
import sys
input = sys.stdin.readline
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())
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(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):
l = [int(x)for x in input().split(' ')]
print(l[2],l[0],l[1])

Solution (Python):
x, y, z  = list(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):
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())

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


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


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

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x



if __name__ == '__main__':
    X, Y, Z = mulinputs()

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

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


import sys
from itertools import accumulate

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

a, b, c = MAP()

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

Solution (Python):
import sys

input = sys.stdin.readline


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

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

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


if __name__ == "__main__":
    main()

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

print(Z, X, Y)

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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



if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

print(Z, X, Y)

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]

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

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

Solution (Python):
x,y,z = map(int,input().split())
print(' '.join(map(str, [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):
one, two, three = map(int ,input().split())

print(three, one,two)

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

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

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

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