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

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

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

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

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

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

Solution (Python):


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



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

Solution (Python):
abc = input().split(' ')
a = abc[0]
b = abc[1]
c = abc[2]

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

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

print(Z,X,Y)

Solution (Python):
from collections import defaultdict, deque
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time

from fractions import gcd

sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

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


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

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


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

Solution (Python):
A1,B1,C1 = map(int, input().split())

A = C1
B = A1
C = B1

print(A,B,C)

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



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

print(X, Y, Z)

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


(X, Y, Z) = (int(i) for i in input().split())

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

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

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

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)

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

print(Z, X, Y)

Solution (Python):
import sys
a,b,c=map(int,sys.stdin.readline().split())
a,b=b,a
a,c=c,a
print(a,b,c)

Solution (Python):
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, C = il()
    A, B = B, A
    A, C = C, A
    print(A, B, C)


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

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

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

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

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

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):


def input_multiple_number():
    return map(str, input().split())


X,Y,Z = input_multiple_number()

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'

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


main()

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

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

print(z,x,y)

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

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

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


def solve():
    A,B,C = map(int, input().split())
    A, B = B, A
    A, C = C, A
    res = ' '.join(map(str, [A,B,C]))
    return str(res)

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

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

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

print(x, y, z)

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

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 = input().split()
print(C+" "+A+" "+B)

Solution (Python):
import sys
xyz=input().rstrip().split()
print(int(xyz[2]),end=" ")
print(int(xyz[0]),end=" ")
print(int(xyz[1]))

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

Solution (Python):



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


print(Z, X, Y)

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

print(z, x, y)

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

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

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 resolve():
    '''
    code here
    '''
    A, B, C = [item for item in input().split()]

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

    print(A, B, C)
if __name__ == "__main__":
    resolve()

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

Solution (Python):
if __name__ == "__main__":
    x, y, z = map(int, input().split())

    print(z, x, y)

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)

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

print(c,a,b)

Solution (Python):
X,Y,Z = list(map(lambda x:int(x),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 = [int(i) for i in 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):
x,y,z = map(int,input().split())
tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp
print(x,y,z)

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

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

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

print(*ans)

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

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

print(C + ' ' + A + ' ' +  B)

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

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

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

"""
Created on Sat Apr  4 20:49:19 2020

@author: naoki
"""

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

print(C, A, B)

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

Solution (Python):
X, Y, Z = 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):
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 math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def print_list(l): print(*l, sep='\n')
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def No(): print('No')

def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime

X,Y,Z = imn()

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

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
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    X, Y, Z = lr()
    A = [0]*3
    A[0] = Z
    A[1] = X
    A[2] = Y
    print(*A, sep=' ')
resolve()

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

print(c,a,b)

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

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

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

Solution (Python):

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


a = y
b = x
c = z



a = z
c = y

print(a, b, c)

Solution (Python):



def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))

a,b,c = invr()
tempa = a
tempc = c
tempb = b
a = tempc
b = tempa
c = tempb
print(a,b,c)

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

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

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

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

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):
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 = 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, sep=' ')

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

Solution (Python):
import sys
 
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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')
INF = 10 ** 18
MOD = 10 ** 9 + 7
 

x,y,z = RI()
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):
import sys
input = lambda: sys.stdin.readline().rstrip()

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

print(C, A, B)

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

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

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

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

Solution (Python):
XYZ = input().split()
X = int(XYZ[0])
Y = int(XYZ[1])
Z = int(XYZ[2])

print(Z,X,Y)

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

print(A, B, C)

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

Solution (Python):
import sys,math,copy,queue,itertools,bisect
from fractions import gcd
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(0,1),(-1,0),(0,-1))
x,y,z = LI()
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(str(z) + " " +  str(x) + " " + str(y))

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

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

print(c, a, b)

Solution (Python):
def main():
    x, y, z = map(int, input().split(" "))
    ans = "{0} {1} {2}".format(z, x, y)
    print(ans)
if __name__ == '__main__':
    main()

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

print(z, x, y)

Solution (Python):












mod = int(1e9+7)
INF = 1<<29
lINF = 1<<35

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

if __name__=='__main__':
    main()

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

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

print("%d %d %d" % (a, b, c))

Solution (Python):
A, B, C = map(int, input().rstrip().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,raw_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,end=" ")
print(b,end=" ")
print(c)

Solution (Python):

a,b,c = [int(x) for x in 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):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

X,Y,Z = input_int()

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

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

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

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

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

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

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

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

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

    print(z, x, y)


if __name__ == "__main__":
    main()

Solution (Python):
def count_section_by_zero(data):
  count = 0
  flg = False
  start = 0
  for i, d in enumerate(data):
    if flg is False and d != 0:
      count += 1
      flg = True
      
    if d == 0:
      flg = False
  return count

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

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

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))


def divide_two(arg):
  c = 0
  while True:
    if c >= 2:
      break
    if arg % 2 != 0:
      break
    arg //= 2
    c += 1
  return c


def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def main():
  a,b,c = input_list()
  a, b = b, a
  a, c = c, a
  print(a, b, c)
  
import math
import fractions
import collections
import itertools
from functools import reduce
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):
if __name__ == '__main__':
    s = input().rstrip().split(' ')
    X = int(s[0])
    Y = int(s[1])
    Z = int(s[2])
    print("{} {} {}".format(Z,X,Y))

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

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

Solution (Python):


MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

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

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

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

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

Solution (Python):
from sys import stdin

A, B, C = [int(x) for x in stdin.readline().rstrip().split()]



temp = A
A = B
B = temp
temp = C
C = A
A = temp
print(A, B, C)

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

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

print(Z, X, Y)

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

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

i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

X, Y, Z = i_l()

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

print(X, Y, Z)

Solution (Python):
from sys import stdin

def main():

    input = stdin.readline

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

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

a=y
b=x

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

Solution (Python):


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

print(Z,X,Y)

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

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

x,y,z = [int(j) for j in sys.stdin.readline().split()]
a = x
x = y
y = a
a = z
z = x
x = a
print(x, y, z)

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

a,b,c=X,Y,Z
a,b=b,a
a,c=c,a

print(a,b,c)

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

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

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


print(*ans,sep=' ')

Solution (Python):

a,b,c=map(int,input().strip().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,sep=' ')

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

print(Z,X,Y)

Solution (Python):

x,y,z = list(map(int,input().split()))
print(" ".join(map(str,[z,x,y])))

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    x, y, z = [int(s) for s in input().strip().split()]
    print(z, x, y)




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


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


if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline


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

Solution (Python):
import bisect,collections,copy,itertools,math,numpy,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())

A,B,C = LI()
B,A = A,B
C,A = A,C
print(A,B,C)

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

Solution (Python):


from sys import stdin
import sys
sys.setrecursionlimit(10**8)

def nextLine(): return next(stdin)
def nextStrList(): return nextLine().split()
def nextIntList(): return [int(_) for _ in nextStrList()]


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


if __name__=="__main__":
	main()