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

a = x
x = y
y = a

a = x
x = z
z = a

print(x, y, z)

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

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

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

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

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

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

print(a, b, c)

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

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

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

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):
from collections import defaultdict
def main():
    x,y,z=map(int,input().split())
    print(z,x,y)
main()

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

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

S = []
S.append(l[2])
S.append(l[0])
S.append(l[1])
print(S[0],S[1],S[2])

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

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

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

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

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

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

Solution (Python):
input_line = input().split()
input_line = [int(s) for s in input_line]
print(str(input_line[2]) + " " + str(input_line[0]) + " " + str(input_line[1]))

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

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

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

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

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

number_A = A
number_B = B
number_C = C

A = number_C
B = number_A
C = number_B

print(A,B,C)

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

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

b = X
c = Y
a = Z

print(a,b,c)

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

tmp = a
a = c
c = tmp

print(a, b, c)

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

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

tmp = y
y = x
x = tmp

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

Solution (Python):
A, B, C = input().split()
print('{} {} {}'.format(C, A, B))

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)


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

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

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

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


temp = x
x = y
y = temp


temp = x
x = z
z = temp

print(x, y, z)

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

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

Solution (Python):
num_list = input()
num_list = num_list.split(' ')

temp = num_list[1] 
num_list[1] = num_list[0] 
num_list[0] = temp 
 
temp = num_list[0] 
num_list[0] = num_list[2] 
num_list[2] = temp 
 
print(' '.join(num_list))

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

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

A=Z
B=X
C=Y
print(A,B,C)

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

Solution (Python):
X = 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 = input().split()
print(x[2]+" "+x[0]+" "+x[1])

Solution (Python):
import os

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


if __name__ == "__main__":
	main()

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

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

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

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










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







x, y = y, x



x, z = z, x



boxA = x
boxB = y
boxC = z

print(boxA, boxB, boxC)

Solution (Python):
num = list(map(int,input().split()))
num[0],num[1] = num[1],num[0]
num[0],num[2] = num[2],num[0]
for i in range(len(num)):
  print(num[i],end=" ")

Solution (Python):
arr= input().split()
ans_list =[]
ans_list.append(arr[2])
ans_list.append(arr[0])
ans_list.append(arr[1])

ans=' '.join(ans_list)
print(ans)

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

Solution (Python):

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

def swap(a,b):
    temp = b
    b = a
    a = temp
    return a,b

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

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

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

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

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

for i in [1, 2]:
  tmp = num_list[0]
  num_list[0] = num_list[i]
  num_list[i] = tmp

print(" ".join(num_list))

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

Solution (Python):
input_num_list=list(map(int,input().split()))
input_num_list.insert(0,input_num_list.pop(2))
print(' '.join(map(str,input_num_list)))

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

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

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

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

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

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

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

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

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

Solution (Python):


import sys


















def main():
    mod = 1000000007                  
    inf = float('inf')
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():  return int(input())
    def mi():  return map(int, input().split())
    def mi_0(): return map(lambda x: int(x)-1, input().split())
    def lmi(): return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():  return list(input())
    
    
    a, b, c = mi()
    print("{} {} {}".format(c, a, b))

if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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):
inputline = list(map(lambda x:int(x), input().split(" ")))
print(inputline[2], inputline[0], inputline[1])

Solution (Python):
x = input()

xs = x.split(" ")

xs[0], xs[1] = xs[1], xs[0]
xs[0], xs[2] = xs[2], xs[0]

print(" ".join(xs))

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

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

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

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

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

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

Solution (Python):
ls=[int(x) for x in input().split()]
print(ls[2],ls[0],ls[1])

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

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

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

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

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

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

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

list_a = [b]
list_b = [a]

list_a = [c]
list_c = [b]

list = list_a + list_b + list_c
print(list_a[0], list_b[0], list_c[0])

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

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

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

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

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

print(a, b, c)

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 = (int(i) for i in input().split())
a,b = y,x
a,c = z,a
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):
import numpy as np
import math as mt
X,Y,Z=map(int, input().split())
print(Z,end=" ")
print(X,end=" ")
print(Y)

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

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

Solution (Python):
line_num = input()
line = line_num.split(" ")
a = line[0]
b = line[1]
c = line[2]
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 = (int(x) for x in input().split())
print("{} {} {}".format(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):
l=list(map(str,input().split()))
ans=[l[2],l[0],l[1]]
for i in ans:
  print(i)

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

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

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

Solution (Python):
list_input_str = input().split(' ')

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

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

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

temp[0], temp[1] = temp[1], temp[0]
temp[0], temp[2] = temp[2], temp[0]

print(' '.join(temp))

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

Solution (Python):
i = input()
l = i.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 = input().split()

a = z
b = x
c = y

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

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

w = x
x = y
y = w

w = x
x = z
z = w

print(x,y,z)

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

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

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

Solution (Python):
from sys import stdin


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    X,Y,Z = list(map(int,_in[0].split(' ')))  
    
    
    
    print(Z,X,Y)

Solution (Python):
from collections import *
from heapq import *
from itertools import *


from decimal import *
import copy
from bisect import *
import time
import sys
import math

input=lambda :sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))

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


a, b = b, a

a, c = c, a

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

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

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

print(z,x,y)

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

Solution (Python):
X, Y, Z = 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 = X
X = Y
Y = tmp
tmp = X
X = Z
Z = tmp
print(str(X)+" "+str(Y)+" "+str(Z))

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

Solution (Python):
def exchange(l, a, b):
    
    w = l[a]
    l[a] = l[b]
    l[b] = w

l = list(map(int, input().split()))
exchange(l, 0, 1)
exchange(l, 0, 2)

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

Solution (Python):
arvud = input()

arvu=arvud.split(" ")
arv1=arvu[0]
arv2=arvu[1]
arv3=arvu[2]

print(arv3+ " "+ arv1+ " "+ arv2)

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

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

Solution (Python):
from sys import stdin

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

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

l = input().split()
print(l[2],l[0],l[1])

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

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

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

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

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

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

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

Solution (Python):
def tmp(x,y):
  tmp = 0
  tmp = x
  x = y
  y = tmp

  return x,y

def main():
  x,y,z = (int(x) for x in input().split())
  x,y = tmp(x,y)
  x,z = tmp(x,z)

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

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

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

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

print(z,x,y)

Solution (Python):
x, y, z = 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 = 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):
from sys import stdin
import math


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

print(Z, X, Y)

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

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

print(z, x, y)

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

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):
l = input().split(' ')

print(str(l[2])+' '+str(l[0])+' '+str(l[1]))

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')
mod = 1000000007




def main():
	A,B,C = inputMap()
	tmp = B
	B = A
	A = tmp
	tmp = C
	C = A
	A = tmp

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





def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

if __name__ == "__main__":
	main()

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

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

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

Solution (Python):

import numpy as np

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

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

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

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

print(c, a, b)

Solution (Python):
def solve():
    x,y,z = map(int,input().split())
    x,y = y,x
    x,z = z,x
    print(x,y,z)
if __name__=='__main__':
    solve()

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

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

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

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

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

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

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

Solution (Python):

DATA = """
5
5 10
ssdss
""".split("\n")

def get_debug_line():
	for i in DATA:
		yield i

if 1:
	get_line = input
else:
	get_line = get_debug_line().__next__
	get_line()

X, Y, Z = [int(i) for i in get_line().strip().split(" ")]
print ("{0} {1} {2}".format(Z, X, Y))

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

l2 = l[1]
l[1] = l[0]
l[0] = l2

l3 = l[2]
l[2] = l[0]
l[0] = l3

L=[str(a) for a in l]
L=" ".join(L)
print(L)

Solution (Python):


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

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


temp = b
b = a
a =temp


temp = c
c = a
a =temp


print(a,b,c)

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

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

Solution (Python):
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
input = sys.stdin.readline

def linput():
    return [int(x) for x in input().split()]

x, y, z = linput()

print(z, x, y)

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

Solution (Python):
xyz = [int(x) for x in input().split()]
print(xyz[2], xyz[0], xyz[1])

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

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

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

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

Solution (Python):
X,Y,Z = (int(x) for x in 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=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, end=" ")
print(x, end=" ")
print(y, end=" ")

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

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

Solution (Python):

boxes = list(map(int, input().split()))
tmp_a, tmp_b = boxes[1], boxes[0]
boxes[0], boxes[1] = tmp_a, tmp_b
tmp_a, tmp_c = boxes[2], boxes[0]
boxes[0], boxes[2] = tmp_a, tmp_c
print(boxes[0], boxes[1], boxes[2])

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

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

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

print(c,a,b)

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

    temp_a = a
    temp_b = b
    a = temp_b
    b = temp_a
    temp_c = c
    temp_a = a
    c = temp_a
    a = temp_c
    print(a, b, c)


resolve()

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

print(a,b,c)

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

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

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):
A,B,C=[int(x) for x in input().split(" ")]
A,B=B,A
A,C=C,A
print(A , B , C)

Solution (Python):
A,B,C=[int(x) for x in input().split(" ")]
temp=B
B=A
A=C
C=temp
print(A , B , C)

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

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

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

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

xyz = [a,b,c]

print(' '.join(xyz))

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

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

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

print(' '.join(l))

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

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

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

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

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

main()

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

Solution (Python):
def main():
    A, B, C = map(int, input().split(' '))
    A, B = B, A
    A, C = C, A
    print(A, B, C)
    
    
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)