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

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

Solution (Python):
s1, s2, s3 = input().split()
print("{} {} {}".format(s3, s1, s2))

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

XYZ = input().split()
XYZ[0],XYZ[1],XYZ[2] = XYZ[2],XYZ[0],XYZ[1]
print(' '.join(map(str, XYZ)))

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


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

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

temp = 0
temp = box[0]
box[0] = box[1]
box[1] = temp

temp = box[0]
box[0] = box[2]
box[2] = temp

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

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

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

for i in B:
    print(i)

Solution (Python):
a,b,c = list(map(int,input().split()))
 
def myFun(x,y):
    val = x
    x = y
    y = val
    return (x,y)
 
a,b = myFun(a,b)
a,c = myFun(a,c)
print(a,b,c)

Solution (Python):
A = list(input().split())


A[0],A[1],A[2] = A[2],A[0],A[1]

print(' '.join(A))

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

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

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

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

tmp = array[0]
array[0] = array[1]
array[1] = tmp

tmp = array[0]
array[0] = array[2]
array[2] = tmp


print("%d %d %d" %(array[0], array[1], array[2]))

Solution (Python):
X,Y,Z=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 = 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):
from sys import stdin
a,b,c = map(int,input().split())
print("{} {} {}".format(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()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

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

quiz[0], quiz[1] = quiz[1], quiz[0]
quiz[0], quiz[2] = quiz[2], quiz[0]
print(quiz[0], quiz[1], quiz[2])

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

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

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

a = x
b = y
c = z

z = str(b)
y = str(a)
x = str(c)

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


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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10


def solve():
    xyz = LI()
    xyz[0], xyz[1] = xyz[1], xyz[0]
    xyz[0], xyz[2] = xyz[2], xyz[0]
    print(*xyz)
    return



if __name__ == '__main__':
    solve()

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

Solution (Python):
line = input()

x, y, z = line.lstrip().rstrip().split(' ')
a = int(x)
b = int(y)
c = int(z)

t = a
a = b
b = t

t = a
a = c
c = t

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

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

Solution (Python):

def main():
    X, Y, Z = [_ for _ in input().split()]
    output = str(Z) + " " + str(X) + " " +str(Y)
    print(output)

main()

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

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

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

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

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

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

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

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

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

Solution (Python):
url = "https://atcoder.jp/contests/abc161/tasks/abc161_a"

def main():

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



if __name__ == '__main__':
    main()

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

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

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

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

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

X = int(B)
Y = int(A)

ZO = X
X = int(C)


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

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

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

Solution (Python):
url = "https://atcoder.jp/contests/abc161/tasks/abc161_a"

def main():

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



if __name__ == '__main__':
    main()

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

print(Z, X, Y)

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

b = [a[2], a[0], a[1]]
print(" ".join(b))

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

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

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

    print(x, y, z)

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

Solution (Python):
a = input()
b = a.split()
c = [0]*len(b)
for i in range(len(b)):
    c[i]= int(b[i])
d = c[0]
e = c[1]
c[0] = c[2]
c[1] = d
c[2] = e

print(' '.join(map(str, c)))

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

Solution (Python):
a,b,c= map(str, input("").split())
tem=a
a=c
c=b
b=tem
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):
def solve():
    a, b, c = map(int, input().split())
    print(c, a, b)


if __name__ == '__main__':
    solve()

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

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 = 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):
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):
data = input().split()
x = int(data[0])
y = int(data[1])
z = int(data[2])

print(z,x,y)

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

Solution (Python):
li = input().split()
print(li[2]+" "+li[0]+" "+li[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  = map(int, input().split())
print(str(z) + " " + str(x) + " " +str(y))

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

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

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

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
import sys,bisect,string,math,time,functools,random
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[];g=[[] for i in range(n)]
    for i in range(E):
        inp=LI();org_inp.append(inp)
        if index==0:inp[0]-=1;inp[1]-=1
        if len(inp)==2:
            a,b=inp;g[a].append(b)
            if not Directed:g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp;aa=(inp[0],inp[2]);bb=(inp[1],inp[2]);g[a].append(bb)
            if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,boundary=1,search=[],replacement_of_found='.',mp_def={'

    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):return [[tb//(n**bt)%n for bt in range(k)] for tb in range(n**k)]
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)
def show2d(g,h,w):
    for i in range(h):show(g[i*w:i*w+w])

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

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

def ran_input():
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True

ans=0



x,y,z=LI()
ans=z,x,y
    
print(*ans)

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

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

x = s[0]
y = s[1]
z = s[2]

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()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

Solution (Python):
l = [x for x in input().split(' ') if x != ' ']
m = []
m.append(l[2])
m.append(l[0])
m.append(l[1])
print(' '.join(map(str, m)))

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

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

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

A = X
B = Y
C = Z

newA1 = B
newB1 = A

newA2 = C
newC2 = newA1

print(newA2, newB1, newC2)

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


t1 = a
a = b
b = t1


t2 = a
a = c
c = t2

print(a, b, c)

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

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())
def swap(a,b):
    temp = a 
    a = b
    b = temp
    return a,b

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

Solution (Python):
a, b, c = [int(w) for w in 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
sys.setrecursionlimit(10000000)


dxdy=((1,0),(0,1))

def pin(type=int):
    return map(type,input().rstrip().split())

def resolve():
    x,y,z=(pin())
    print(z,x,y)
"""         


"""
"""
お前カッコ閉じ,るの忘れてるだろ
"""
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """1 2 3"""
        output = """3 1 2"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """100 100 100"""
        output = """100 100 100"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """41 59 31"""
        output = """31 41 59"""
        self.assertIO(input, output)


if __name__ == "__main__":
    resolve()

Solution (Python):

import collections


def solve(x, y, z):
    return " ".join(map(str, [z, x, y]))


[x, y, z] = list(map(int, input().strip().split()))
print(solve(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=map(int,input().split())
print(z, x, y)

Solution (Python):
from sys import stdin
A, B, C = map(int, stdin.readline().rstrip().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, raw_input().split())

def swap(A, B):
    return B, A

X, Y = swap(X, Y)
X, Z = swap(X, Z)
print(str(X) + " " + str(Y)+ " " + str(Z))

Solution (Python):

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

Solution (Python):
import math
import numpy as np

w=0
x,y,z=(int(x) for x in input().split())
w=x
x=z
z=y
y=w
print(x,y,z,sep=" ")

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

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

Solution (Python):
N = 3
A = [int(N) for N in input().split()]
C =[0]*3
C[0]=A[1]
C[1]=A[0]
C[2]=A[2]
A[0]=C[2]
A[1]=C[1]
A[2]=C[0]
for i in range(3):
    print(A[i])

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().strip().split())

print(z, x, y)

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

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

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

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
rr = range


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols
    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])
    return ret


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_map_as_int(H):
    '''
    
    '''
    ret = []
    for _ in range(H):
        ret.append([1 if s == '
        
        
    return ret


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from fractions import gcd


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


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

Solution (Python):
i = list(map(int, input().split()))
X = i[0]
Y = i[1]
Z = i[2]
swap=[Z,X,Y]
swap_moji=map(str, swap)
ZXY=' '.join(swap_moji)
print(ZXY)

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

Solution (Python):



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

for i in range(3):
    print(a[-1+i], end=" ")

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

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



if __name__ == "__main__":
    a()

Solution (Python):
import math

S =  list(map(int,input().split()))
X = S[0]
Y = S[1]
Z = S[2]
S[0],S[1] = S[1],S[0]
S[0],S[2] = S[2],S[0]
print(S[0],S[1],S[2])

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):
def swap(A, B):
    return (B, A)

if __name__ == "__main__":
    X, Y, Z = input().split()
    X, Y = swap(X, Y)
    X, Z = swap(X, Z)
    print(X, Y, Z)

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

print(c, a, b)

Solution (Python):


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

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

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

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

Solution (Python):
'''Swap the integer in each box'''
A, B, C = [int(i) for i in input("").split()]
New = A
A = B
B = New
New1 = A
A = C
C = New1
print(A, B, C)

Solution (Python):
nums = [int(e) for e in input().split()]
a = nums[0]
nums[0] = nums[1]
nums[1] = a
a=nums[0]
nums[0] = nums[2]
nums[2] = a
print(str(nums[0]) + ' ' + str(nums[1]) + ' ' + str(nums[2]))

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
x,y = swap(x,y)
x,z = swap(x, z)
print(x,y,z)

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

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

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

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

Solution (Python):

"""
Created on Sun Jan 19 20:52:57 2020

@author: over-
"""

X,Y,Z=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):
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    x = kwargs["x"]
    y = kwargs["y"]
    z = kwargs["z"]

    res = " ".join([z, x, y])
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    
    
    
    kwargs["x"], kwargs["y"], kwargs["z"] = cin

    cout = main(kwargs)
    print(cout)

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

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

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

print(z,x,y)

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

if __name__ == "__main__":
    main()

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

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=input().split()
a=x[0]
b=x[1]
c=x[2]
a,b=b,a
a,c=c,a
print(a+" "+b+" "+c)

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

Solution (Python):
from copy import copy

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


temp = copy(A)
A = copy(B)
B = copy(temp)


temp = copy(A)
A = copy(C)
C = copy(temp)

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
def main():
    x,y,z = map(int, input().split())
    tmp = x
    x = y
    y = tmp
    tmp = x
    x = z
    z = tmp
    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(' '))
print(Z, X, Y)

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

Solution (Python):


input_d1 = list(input().split())
X = input_d1
print(X[2],X[0],X[1])

Solution (Python):



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


def main():
    print(Z, X, Y)


if __name__ == "__main__":
    main()

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

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

print(a, b, c)

Solution (Python):

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

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

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

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

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

c = e[0]
d = e[2]
e[0]= d
e[2]= c
for i in range(3):
  print(e[i], end =" ")

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

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Solution (Python):
x,y,z = list(map(int,input().split()))
 
def swap(a,b):
    tmp = a
    a = b
    b = tmp
    return (a,b)
 
x,y = swap(x,y)
x, z = swap(x, z)
print(x,y,z)

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

B=X
C=Y
A=Z

print(A,B,C)

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

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

print(c, a, b)

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


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

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

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

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

Solution (Python):
A,B,C=map(str,input().split())
if len(A)>=0:
    print(C,A,B)

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

def swap(A, B):
    temp = A
    A = B
    B = temp
    return A, B
    
def main():
    X, Y, Z = map(int, input().rstrip().split())
    A = X
    B = Y
    C = Z
    A, B = swap(A, B)
    A, C = swap(A, C)
    print(" ".join(map(str, [A, B, C])))
    

if __name__ == "__main__":
    main()

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

L[0]=B
L[1]=A
A=L[0]
B=L[1]

L[0]=C
L[2]=A
A=L[0]
C=L[2]

print(' '.join(map(str, L)))

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

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

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

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

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

print(num[2] + " " + num[0] + " " + num[1])

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

print (Z,X,Y)

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

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

print(Z, X, Y)

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

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

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

Solution (Python):








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

a = z
b = x
c = y

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

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

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

Solution (Python):

"""
Created on Sat Apr  4 20:51:41 2020

@author: liang
"""

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())
tmp = A
A = B
B = tmp

tmp = A
A = C
C = tmp

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

Solution (Python):
import sys

def main():

	List = list(map(int, input().split()))
	print(List[2],List[0], List[1])

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

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

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

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

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

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