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

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

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

swap = A
A = B
B = swap

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

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


if __name__ == "__main__":
    main()

Solution (Python):
x = input().split()
a,b,c = x[0], x[1], x[2]
print(c + ' ' + a + ' ' + b)

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

Solution (Python):
X,Y,Z=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())
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())
ABC = [z, x, y]
print(" ".join(map(str, ABC)))

Solution (Python):


import sys
sys.setrecursionlimit(300000)


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

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

if __name__ == '__main__':
    main()

Solution (Python):
x,y,z=map(int,raw_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())
x1 = y
y1 = x
x = z
z1 = x1
print(x, y1, z1)

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

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


tmp = x
x = y
y = tmp

tmp = x
x = z
z = tmp

print(x, y, z)

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

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

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

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

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

Solution (Python):

X, Y, Z = map(int, input().split())
A, B, C = X, Y, Z
A, B = B, A
A, C = C, A
print('{} {} {}'.format(A, B, C))

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

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

print(a, b, c)

Solution (Python):

x,y,z=map(int,raw_input().split())
x,y=y,x
x,z=z,x
print x,y,z

Solution (Python):
import sys


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


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

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


if __name__ == '__main__':
    main()

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

Solution (Python):

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

if (a == b == c):
    print(str(a) + ' ' + str(b) + ' ' + str(c))
else:
    a, b = b, a
    a, c = c, a
    print(str(a) + ' ' + str(b) + ' ' + str(c))

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

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

Solution (Python):
N = list(map(str, input().split()))

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

print(' '.join(A))

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

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

print(str(A) + " " + str(B) + " " + str(C))

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

print(Z, X, Y)

Solution (Python):

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

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

Solution (Python):

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

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

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

Solution (Python):

import sys


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


if __name__ == '__main__':
    main()

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


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

x,y,z = get_nums_l()

print( z, x, y )

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

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

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

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

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

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

Solution (Python):
*s,c=input().split();print(c,*s)

Solution (Python):
*s,c=input().split();print(c,*s)

Solution (Python):

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


if __name__ == "__main__":
    main()

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



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

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

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

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

print(X, Y, Z)

Solution (Python):
import copy

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

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

A = Z
B = X
C = Y

print(str(A) + " " + str(B) + " " + str(C))

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

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

b = [a[2], a[0], a[1]]

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

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

a = z
b = x
c = y

print(a, b, c)

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

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

a1 = b
b1 = a
a2 = c
c1 = a1

print(a2, b1, c1)

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

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

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

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

print(x, y, z)

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

print(z, x, y)

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

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

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

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    X, Y, Z = MI()

    tmp = Y
    Y = X
    X = tmp
    tmp = Z
    Z = X
    X = tmp

    print(X, Y, Z)


if __name__ == '__main__':
    main()

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

INF = float('inf')


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

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

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

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

print(x , y, z)

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

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

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

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

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

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

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

Solution (Python):
l = [int(x) for x in input().split()]
print('{} {} {}'.format(l[2],l[0],l[1]))

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

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

print(z, x, y)

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

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

print(Z,X,Y)

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    x,y,z = map(int,input().split())
    print(z,x,y)
resolve()

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

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

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

order = [2, 0, 1]
shuffle = []

for i in order :
    shuffle.append(data[i]+' ')

output = " ".join(shuffle)
print(output)

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

Solution (Python):

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

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

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

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

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


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

    w = X
    X = Y
    Y = w
    w = X
    X = Z
    Z = w

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
import itertools
import queue
import numpy as np
input = sys.stdin.readline
sys.setrecursionlimit(100000)


def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
import itertools
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)


def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


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

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

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

Solution (Python):
a = input()
b = a.split()
print(b[2]+' '+b[0]+' '+b[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):
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())

d = a
a = b
b = d

d = a
a = c
c = d

print(a, b, c)

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

A=' '.join([X[2], X[0], X[1]])

print(A)

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

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

Solution (Python):
def RA():
    l = input().split()
    return [int(i) for i in l]
arr = RA()
print(arr[2], arr[0], arr[1])

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

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

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

Solution (Python):
x, y, z = map(str, input().split())
a = [x, y, z]
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
b = '  '.join(a)
print(b)

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

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

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

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

print(c,a,b)

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

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

print(z,x,y)

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

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

Solution (Python):
s = input().split()
A = s[0]
B = s[1]
C = s[2]

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

Solution (Python):
def inputs(): return [int(x) for x in input().split()]
x,y,z = inputs()
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, z = z, x, y
print("{0} {1} {2}".format(x, y, z))

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())
a=Y
b=X
c=a
a=Z
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 = map(int, input().split());
d = a;
e = b;
a = c;
b = d;
c = e;
print(a,b,c)

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

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

print("%d %d %d" % (Z, X, Y))

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

Solution (Python):
X,Y,Z = map(int, raw_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):
str = input().split()
new = []
new.append(str[2])
new.append(str[0])
new.append(str[1])
print(new[0] + " " + new[1] + " " + new[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):
a,b,c = map(int,input().split())
print(c,a,b)

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

Solution (Python):
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())
tmp = X
X = Y
Y = tmp

tmp_ = X
X = Z
Z = tmp_

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

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

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

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

print(' '.join(map(str, [A,B,C])))

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

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

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

ans =  " ".join([Z, X , Y])
print(ans)

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

Solution (Python):
a = input().split()
b = ""
n = a[0]
a[0] = a[1]
a[1] = n
n = a[0]
a[0] = a[2]
a[2] = n
for i in a:
    b = b + i + " "
print(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().strip().split(" "))

tmp = a
a = b
b = tmp


tmp = a
a = c
c = tmp
print(" ".join(map(str, [a, b, c])))

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



X,Y,Z = LI()

print(Z,X,Y)

Solution (Python):

if True:
    a,b,c=input().split()
    a,b=b,a
    a,c=c,a
    print(a,b,c)

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

Solution (Python):




def solve(x, y, z):
    x, y = y, x
    x, z = z, x
    return x, y, z


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

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

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

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

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

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

Solution (Python):
l_input = [int(e) for e in input().split()]
l_output = [l_input[2], l_input[0], l_input[1]]
print(*l_output)

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

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):
def q1():
    X,Y,Z = (int(i) for i in input().split())
    print('{} {} {}'.format(Z,X,Y))


if __name__ == '__main__':
    q1()

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

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

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

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

Solution (Python):


import sys

def main():
    x, y, z = map(int, sys.stdin.readline().strip().split(' '))
    print(z, x, y)

if __name__ == "__main__":
    main()

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

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

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

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

temp = B
B = A
A = temp

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

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

Solution (Python):
X, Y, Z = input().split()
A = X
B = Y
C = Z
temp = A
A = B
B = temp
temp = A
A = C
C = temp

print(A, B, C);

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

print(z,x,y)

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

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

print(Z,X,Y)

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

Solution (Python):
m,n,o = input().split()
m = int(m)
n = int(n)
o = int(o)
m,n = n,m
m,o = o,m
print(m,n,o)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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().rstrip().split())
print(c,a,b)

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(" ".join(map(str, [Z,X,Y])))


if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline

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

print(Z, X, Y)

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

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)