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):
numbers = input().split()
numbers = [int(n) for n in numbers]
assert len(numbers) == 3
x,y,z=numbers
x,y = y,x
x,z = z,x 
print(x,y,z)

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

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

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

Solution (Python):
import sys
A, B, C = map(int,sys.stdin.readline().split())
print(C, A, B, sep=" ")

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

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

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

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

    print(Z, X, Y)

if __name__ == '__main__':
    resolve()

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

print(z, x, y)

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

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

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

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

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)


main()

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

print(z,x,y)

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

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

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

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

temp = -1

temp = y
y = x
x = temp

temp = z
z = x
x = temp

print(x, y,z)

Solution (Python):
inp = list(map(lambda x: int(x), input().split(" ")))
print("{} {} {}".format(inp[2],inp[0],inp[1]))

Solution (Python):
X, Y, Z = list(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())
num1 = X
X = Y
Y = num1
num2 = X
X = Z
Z = num2
print("{} {} {}".format(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):
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 = 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("{0} {1} {2}".format(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())

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


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

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

Solution (Python):
import sys

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

print(a, b, c)

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

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

Solution (Python):
if __name__ == '__main__':
	X, Y, Z = map(int, input().split())
	X, Y , Z = Z, X , Y

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

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

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

Solution (Python):

from sys import stdin
from operator import itemgetter
import math


a, b, c = [int(x) for x in stdin.readline().rstrip().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(a,b,c)

Solution (Python):
def abc_swap(x, y, z):
    x, y = y, x
    x, z = z, x
    print(x, y, z)

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

abc_swap(x, y, z)

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

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

print('{0} {1} {2}'.format(z, x, y))

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

List = []
List.append(c)
List.append(a)
List.append(b)
print(*List)

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

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

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

Solution (Python):

x, y, z = list(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,"",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 = 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 = (str(x) for x in input().split())
print(c+" "+a+" "+b)

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

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

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

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

Solution (Python):

init = [int(s) for s in input().rstrip().split(' ')]
print(init[2],init[0],init[1])

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

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

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

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

tmp_a = a

a = b
b = tmp_a

tmp_a = a

a = c
c = tmp_a

print(a,b,c)

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

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

tmp = 0
tmp = XYZ[0]
XYZ[0] = XYZ[1]
XYZ[1] = tmp

tmp = XYZ[0]
XYZ[0] = XYZ[2]
XYZ[2] = tmp

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

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

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

Solution (Python):

"""
Created on Sat Apr  4 21:00:18 2020

@author: Kanaru Sato
"""

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

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

lis = [x,y,z]

print(" ".join(map(str,lis)))

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):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

Solution (Python):

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


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

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

Solution (Python):
n, x, y = input().split(" ")
n, x, y = int(n), int(x), int(y)
print(y, n, x)

Solution (Python):
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq


def iip(listed):
    ret = [int(i) for i in input().split()]
    if len(ret) == 1 and not listed:
        return ret[0]
    return ret


def main():
    X, Y, Z = iip(True)
    print(Z, X, Y)

    
    


def solve():
    N = iip(False)
    S = input()




def split_print_space(s):
    print(" ".join([str(i) for i in s]))


def split_print_enter(s):
    print("\n".join([str(i) for i in s]))


def koenai_saidai_x_index(sorted_list, n):
    l = 0
    r = len(sorted_list)
    if len(sorted_list) == 0:
        return False
    if sorted_list[0] > n:
        return False

    while r - l > 1:
        x = (l + r) // 2
        if sorted_list[x] == n:
            return x
        elif sorted_list[x] > n:
            r = x
        else:
            l = x
    return l


def searchsorted(sorted_list, n, side):
    if side not in ["right", "left"]:
        raise Exception("sideはrightかleftで指定してください")

    l = 0
    r = len(sorted_list)

    if n > sorted_list[-1]:
        
        return len(sorted_list)
    if n < sorted_list[0]:
        return 0

    while r - l > 1:
        x = (l + r) // 2
        if sorted_list[x] > n:
            r = x
        elif sorted_list[x] < n:
            l = x
        else:
            if side == "left":
                r = x
            elif side == "right":
                l = x

    if side == "left":
        if sorted_list[l] == n:
            return r - 1
        else:
            return r

    if side == "right":
        if sorted_list[l] == n:
            return l + 1
        else:
            return l


def soinsuu_bunkai(n):
    ret = []
    for i in range(2, int(n ** 0.5) + 1):
        while n % i == 0:
            n //= i
            ret.append(i)
        if i > n:
            break
    if n != 1:
        ret.append(n)
    return ret


def conbination(n, r, mod, test=False):
    if n <= 0:
        return 0
    if r == 0:
        return 1
    if r < 0:
        return 0
    if r == 1:
        return n
    ret = 1
    for i in range(n - r + 1, n + 1):
        ret *= i
        ret = ret % mod

    bunbo = 1
    for i in range(1, r + 1):
        bunbo *= i
        bunbo = bunbo % mod

    ret = (ret * inv(bunbo, mod)) % mod
    if test:
        
        pass
    return ret


def inv(n, mod):
    return power(n, mod - 2)


def power(n, p, mod_=mod):
    if p == 0:
        return 1
    if p % 2 == 0:
        return (power(n, p // 2, mod_) ** 2) % mod_
    if p % 2 == 1:
        return (n * power(n, p - 1, mod_)) % mod_


if __name__ == "__main__":
    main()

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

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

Solution (Python):



def main():
    x, y, z = input().split()
    print(" ".join([z, x, y]))


if __name__ == '__main__':
    main()

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

Solution (Python):
X,Y,Z=map(int,input().split())
a=Y
b=X
c=Z
d=a
e=c
a=e
c=d 
print(str(a)+" "+str(b)+" "+str(c))

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


def input_int(): return int(input())

def map_int_input(): return map(int, input())

MII = map_int_input

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

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())


def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

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


def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

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

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

import sys


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



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):
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 = (int(x) for x in 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):
def resolve():
    X, Y, Z = input().split()

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


resolve()

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())
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(str(A) + ' ' + str(B) + ' ' + str(C))

Solution (Python):
def main():

    A, B, C = map(int, input().split())
    return " ".join(map(str, [C, A, B]))

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

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

print(" ".join([z, x, y]))

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

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

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

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

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

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):
m = map(int,raw_input().split())
m[0],m[1] = m[1],m[0]
m[0],m[-1] = m[-1],m[0]
print ' '.join([str(i) for i in m])

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

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

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

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

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

Solution (Python):
from collections import defaultdict
import math
N, X, Y = map(int, input().split(' '))
print(Y, N, X)

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

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

print(c,a,b)

Solution (Python):
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

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

def inpl_str(): return list(sys.stdin.readline().split())

x, y, z = inpl_str()
print(z + ' ' + x + ' ' + y)

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

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

d = a
a = b
b = d

e = a
a = c
c = e

print (a,b,c)

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

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

print(X, Y, Z)

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

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

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

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

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

Solution (Python):
if __name__ == '__main__':
    a, b, c = tuple([int(i) for i in input().split()])

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

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

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

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

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

Solution (Python):
X = list(map(int, input().split()))
Y = [str(X[2]), str(X[0]), str(X[1])]
print(" ".join(Y))

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

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

print(z, x, y)

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

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

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

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

Solution (Python):
def resolve():
    x, y,z = map(int, input().split())
    a,b,c = x,y,z
    b=x
    a=y
    c=a
    a=z  
    print(a,b,c)
        
if __name__ == "__main__":
    resolve()

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

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

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

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

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

Solution (Python):
input_line = input()
Line = input_line.split()
Line = [int(s) for s in Line]

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

Solution (Python):
input = raw_input

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

xx = x
x = z
z = xx

print("%d %d %d" % (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 solve(*args: str) -> str:
    x, y, z = args[0].split()
    x, y = y, x
    x, z = z, x

    return ' '.join([x, y, z])


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

Solution (Python):
x, y ,z = list(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):
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 numpy as np
import itertools
import collections
from collections import deque

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline

h = itertools.combinations_with_replacement
p = itertools.permutations

def main():
    
    A, B, C = map(int, input().split())
    tmp = B
    B = A
    A = tmp

    tmp = C
    C = A
    A = tmp

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

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

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

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

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

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 = [int(n) for n in input().split()]

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

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

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

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

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

print(z,x,y)

Solution (Python):
i = list(map(int, input().split())) 
X = i[0]
Y = i[1]
Z = i[2]

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

print(Z,X,Y)

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

print(' '.join([str(x) for x in [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(' '.join([z,x,y]))

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

Solution (Python):
A,B,C=input().split()
print(" ".join([C,A,B]))

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

D = X
X = Z
Z = D

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

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

Solution (Python):

import sys


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



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

Solution (Python):
import sys
import os

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

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

Solution (Python):



import sys


def input():
    return sys.stdin.readline()


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

    print(z, x, y)


if __name__ == "__main__":
    resolve()

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

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

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

print(c,a,b)

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

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

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

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(str(Z)+' '+str(X)+' '+str(Y))

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

Solution (Python):
abc = input().split();
a,b,c = int(abc[0]),int(abc[1]),int(abc[2]);
print('{} {} {}'.format(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,end=" ")
print(x,end=" ")
print(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("{} {} {}".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())

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

print(X,Y,Z)

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

a = z
b = x
c = y

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

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

print (x, y, z)

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

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

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

Solution (Python):
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

X, Y, Z = input().split()
X, Y, Z = Z, X, Y
print(X + ' ' + Y + ' ' + Z)

Solution (Python):
import sys

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

print(Z, X, Y)

Solution (Python):
x,y,z = list(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())
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('{} {} {}'.format(x,y,z))

Solution (Python):
def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
    return arr

arr = input().split()
arr = swap(arr, 0, 1)
arr = swap(arr, 0, 2)
print(" ".join(arr))

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(1000000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(X, Y, Z):
    X, Y = Y ,X
    X, Z = Z, X
    return X, Y, Z


def main():
    X, Y, Z = read_int_n()
    print(*slv(X, Y, Z))


if __name__ == '__main__':
    main()