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

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

print(Z, X, Y)

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq


MOD = 1000000007


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


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


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def is_prime(n):
    if n == 1:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def main():
    A, B, C = get_inputs(int)
    print("{} {} {}".format(C, A, B))


if __name__ == '__main__':
    main()

Solution (Python):
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect




from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7

def main():
  x, y, z = map(int, readline().split())
  print(z, x, y)
  
  
if __name__ == '__main__':
  main()

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

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

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

Solution (Python):

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

Solution (Python):
import sys
input = sys.stdin.readline
X, Y, Z= (int(i) for i in input().split())



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

print(X, Y, Z)

Solution (Python):




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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
import heapq
from operator import itemgetter
 
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

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

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

print(z, x, y)

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

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

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

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

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

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

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

def check(s):
    for i in range(len(s)):
        if s[i] != s[len(s)-1-i]:
            return False
    return True

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


if __name__ == '__main__':
    main()

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

print(z, x, y)

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

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

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






print(x,y,z)

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

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):
import sys
from math import ceil, floor
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

print(C, A, B)

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

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

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

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

print(z,x,y)

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

print(Z,X,Y)

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

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    x, y, z = map(int, rl().split())
    print(z, x, y)


if __name__ == '__main__':
    solve()

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	S = LI()
	S[0],S[1]=S[1],S[0]
	S[0],S[2]=S[2],S[0]
	printH(S)

if __name__ == '__main__':
	main()

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

print("{} {} {}".format(C,A,B))

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

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

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

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

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

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

print(c,a,b)

Solution (Python):

def main():
  
  
  
  
  
  
  
  
  
  
  
  
  import sys
  sys.setrecursionlimit(10**6)
  readline = sys.stdin.readline
  ints = lambda: map(int, readline().split())
  floats = lambda: map(float, readline().split())
  pyes = lambda: print("Yes")
  pno = lambda: print("No")
  lli = lambda I, J: [[0] * J for _ in range(I)]
  mod = 10**9+7

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

if __name__ == '__main__':
  main()

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

print(Z,X,Y)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
ZIP = lambda: zip(*(MAP() for _ in range(n)))

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


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

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

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

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

Solution (Python):
import bisect,sys
import math
from collections import deque

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % mod) % mod
        
    return CONV()



sys.setrecursionlimit(200005)

def main():
    X,Y,Z = isRaw()
    ans = " ".join([str(a) for a in [Z,X,Y]])
    return ans

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

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

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

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

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

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

print(Z,X,Y)

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

print(z,x,y)

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

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

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

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

Solution (Python):
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, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

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

resolve()

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

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

print(c,a,b)

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

print(Z,X,Y)

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

Solution (Python):
X, 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], sep=' ')

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):
from collections import deque
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint

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

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col):
    data.sort(key=lambda x:x[col],reverse=False)
    return data

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

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

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

if __name__ == '__main__':
    solve()

Solution (Python):
def get_ints():
    return map(int, input().split())

x, y, z = get_ints()
print('%d %d %d' % (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):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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

print(c,a,b)

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

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

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    x, y, z = LI()
    print(z, x, y)

main()

Solution (Python):
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:input()

"""========main code==============="""

x,y,z=ml()
x,y=y,x
x,z=z,x
print(x,y,z)
"""for _ in range(t):
    x=ii()"""

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

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b, c = MAP()

print(c, a, b)

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

print(Z,X,Y)

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

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

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

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

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

print(X, Y, Z)

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

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

Solution (Python):

import sys


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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    Z = int(next(tokens))  
    solve(X, Y, Z)

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):



 
import sys
import math



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 

t=1
for tt in range(t):
    
    a,b,c= map(int, sys.stdin.readline().split(' '))
    print(c,a,b)
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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

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

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

Solution (Python):
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

a,b,c = nm()

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

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

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

Solution (Python):

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

print(Z, X, Y)

Solution (Python):

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

Solution (Python):
import sys

def solve():
      input = sys.stdin.readline
      X, Y, Z = map(int, input().split())
      print(Z, X, Y)

      return 0

if __name__ == "__main__":
      solve()

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

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


if __name__ == '__main__':
    main()

Solution (Python):

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


print(Z,X,Y)

Solution (Python):

import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from heapq import heappop,heappush
import time
import os
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def fac_list(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s


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

Solution (Python):


"""
about module
"""

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys

if __name__ == "__main__":
    N, A, B = map(int,input().split())
    
    print(B, N, A)

Solution (Python):
a,sd,f=map(int,input().split())
print(f,a,sd)

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

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

if __name__ == '__main__':
    main()

Solution (Python):
X, Y, Z = map(int, input().split())
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):
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):
def examA():
    X, Y, Z = LI()
    X, Y = Y,X
    X,Z = Z, X
    print(X,Y,Z)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**6)

if __name__ == '__main__':
    examA()

"""

"""

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

print(Z,X,Y)

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

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi

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

import sys


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

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

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

if __name__ == "__main__":
    main()

Solution (Python):


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

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

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


print(Z,X,Y)

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

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

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

print(Z, X, Y)

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

Solution (Python):


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

print(Z,X,Y)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
X, Y, Z = [int(x) for x in input().strip().split()]

print(Z, X, Y)

Solution (Python):
from sys import exit, setrecursionlimit
setrecursionlimit(10**6)

def array2D(row, col ,val=0):
    return [[val]*col for i in range(row)]

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

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

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

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

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

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

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