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):
import sys
sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1
def II(): return int(input())

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

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

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

    print(z, x, y)


if __name__ == '__main__':
    solve()

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

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

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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
import sys
def I(): return int(input())  
def Is(): return map(int, input().split())  
def LI(): return list(map(int, input().split()))  
def TI(): return tuple(map(int, input().split()))  
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  
def LS(): return list(input())  
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

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

Solution (Python):
def swap(A,B):
    a = A
    A = B
    B = a
    return A,B
X,Y,Z = map(int,input().split())
X,Y = swap(X,Y)
X,Z = swap(X,Z)
print(str(X)+' '+str(Y)+' '+str(Z))

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
x,y,z = [int(i) for i in readline().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):
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()
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):
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 copy
import random
import bisect 
import fractions 
import math
import sys
import collections

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

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

X, Y, Z = LI()

print(Z, X, Y)

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]
 
sys.setrecursionlimit(1000000)
mod = 1000000007
 
def solve():
  x,y,z = map(int,input().split())
  print(z,x,y)
  return
 

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

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

Solution (Python):



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


A, B = B, A

A, C = C, A

print(A, B, C)

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

print(z,x,y)

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

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

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

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

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

reg = x
x = y
y = reg
reg = x
x = z
z = reg

print(x, y, z)

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

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

print(X, Y, Z)

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

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

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

print(z,x,y)

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

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

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

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

Solution (Python):
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(str, input().split())
print(Z, X, Y)

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

acswap=x
x=z
z=acswap

print(x,y,z)

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

if __name__ == '__main__':
	main()

Solution (Python):

import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce

from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
  bunshi=1
  bunbo=1
  for i in range(r):
    bunbo = bunbo*(i+1)%mod
    bunshi = bunshi*(n-i)%mod
  return (bunshi*pow(bunbo,mod-2,mod))%mod
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())

li = LI()
print(li[2],li[0],li[1])

Solution (Python):

def LI(): return list(map(int,input().split()))
li = LI()
print(li[2],li[0],li[1])

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

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

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

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

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

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

print(x,y,z)

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

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

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

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

Solution (Python):


a,b,c=(int(x) for x in input().split())

d=0

d=a
a=b
b=d
d=a
a=c
c=d

print(a,b,c)

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

print(C, A, B)

Solution (Python):

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

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

Solution (Python):
n = input()
X = n.split(" ")[0]
Y = n.split(" ")[1]
Z = n.split(" ")[2]
A = X
B = Y
C = Z
X = B
Y = A
X = C
Z = B
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())
A,B,C=X,Y,Z
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):

from sys import stdin, stdout
import math
import bisect
from collections import defaultdict
import datetime
import random

x,y,z = stdin.readline().strip().split()

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

stdout.writelines(' '.join([x,y,z]))

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

Solution (Python):
s = input().split()
x = s[0]
y = s[1]
z = s[2]


print(z + " " +x + " " + y)

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

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

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

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

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

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

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

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

a=l[0]
b=l[1]
c=l[2]

l[0]=c
l[1]=a
l[2]=b

print(*l)

Solution (Python):


def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    a, b, c = read_ints()
    return ' '.join(map(str, [c, a, b]))


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

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

Solution (Python):
a = (input().split())
b = a[2],a[0],a[1]
for i in b:
    print (i,end=" ")

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

x = str(X)
y = str(Y)
z = str(Z)
print(z + " " + x + " " + y)

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

A = x
B = y
C = z


A = y
B = x

A = z
C = y

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

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

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

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

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

chg_box = x
x = y
y = chg_box

chg_box = x
x = z
z = chg_box

print(x,y,z)

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

s = [z,x,y]

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

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):
import sys
X, Y, Z = map(int, sys.stdin.readline().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(" "))
print(z, x, y)

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

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

print(Z,X,Y)

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

print(c,a,b)

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

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

Solution (Python):
one, two, three = map(int, input().split())

print(three, one, two)

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(str, 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())
print('{0} {1} {2}'.format(c,a,b))

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

Solution (Python):
from sys import stdin

a, b, c = [int(x) for x in stdin.readline().rstrip().split()]

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

Solution (Python):
def swp(x, y):
  swp = x
  x = y
  y = swp
  return x, y
  

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

A, B = swp(A, B)
A, C = swp(A, C)

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

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

Solution (Python):
if __name__ == "__main__":
    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):

X,Y,Z=(int(x) for x in 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())
A, B, C = c, a, b
print(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):
if __name__ == '__main__':
    x, y, z = map(int, input().split())
    print(z, x, y)

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

print( c, a, b )

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

x_temp = x
x = y
y = x_temp

x_temp = x
x = z
z = x_temp

print(x, y, z)

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

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


def main():
	X,Y,Z = getlist()
	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

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

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

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

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

print(Z, X, Y)

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

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())
X_0 = Z
Y_0 = X
Z_0 = Y
print(X_0,Y_0,Z_0,sep=' ')

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

Solution (Python):
import sys;input=lambda:sys.stdin.readline().rstrip();aint=lambda:int(input());ints=lambda:list(map(int,input().split()))
import math;floor,ceil=math.floor,math.ceil
from collections import deque
Yes=lambda b:print('Yes')if b else print('No');YES=lambda b:print('YES')if b else print('NO')
is_even=lambda x:True if x%2==0 else False

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

if __name__ == '__main__':
    main()

Solution (Python):
box = list(input().split())
box[0], box[1], box[2] = box[2], box[0], box[1]
print(" ".join(box))

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

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

if __name__ == "__main__":
    resolve()

Solution (Python):

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

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

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

print(Z, X, Y)

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

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

l.append(z)
l.append(x)
l.append(y)

print(*l)

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

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

print(int(z), int(x), int(y))

Solution (Python):
s = input()
x = s.split()[0]
y = s.split()[1]
z = s.split()[2]

tmp = x
x = y
y = tmp
tmp = x
x = z
z = tmp

print(x, y, z)

Solution (Python):
list_ = list(map(int, input().split()))
tmp = list_.pop()
list_.insert(0,tmp)
list_ = [str(_) for _ in list_]
print(' '.join(list_))

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("{} {} {}".format(Z, X, Y))

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

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

Solution (Python):

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

  print(x, y, z)

main()

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

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

Solution (Python):
import sys

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

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

print(Z,X,Y)

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





a,b,c = inputSL()

print(c,a,b)

Solution (Python):
def main():
    X, Y, Z = map(int, input().split())
    print(Z, X, Y)
if __name__ == "__main__":
    main()

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

Solution (Python):
x=list(input().split());a=[x[2],x[0],x[1]];print(' '.join(a))

Solution (Python):
if __name__ == '__main__':
	nums= list(map(int,input().split(" ")))
	print("%d %d %d"%(nums[2], nums[0], nums[1]))

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

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

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

x1, y1, z1 = y, x, z
x2, y2, z2 = z1, y1, x1

print(x2, y2, z2)

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

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

a = z
b = x
c = y

               
print(a, b, c)

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

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


B = [str(a) for a in b]
B = " ".join(B)
print(B)

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

a = z
b = x
c = y

               
print(a, b, c)

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 = input().split(" ")

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

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

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

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

Solution (Python):



from collections import deque

A = deque(list(map(int, input().split())))
tmp = A.pop()
A.appendleft(tmp)
print(A[0], A[1], A[2])

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

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

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

print(Z,X,Y)

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

temp_AB = x
x = y
y = temp_AB

temp_AC = x
x = z
z = temp_AC

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())
tmp = X
X = Y
Y = tmp
tmp2 = X
X = Z
Z = tmp2

print(X,Y,Z)

Solution (Python):

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


tmp = A
A = B
B = tmp

tmp = A
A = C
C = tmp



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

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

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

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

Solution (Python):
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):
line = input().rstrip().split(" ")
N = [str(n) for n in line]
X = N[0]
Y = N[1]
Z = N[2]
tmp = 0

tmp = X
X = Y
Y = tmp

tmp = X
X = Z
Z = tmp

print(X,Y,Z)

Solution (Python):
inp=[int(x) for x in input().split()]
print(inp[2],inp[0],inp[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=input()
b=a.split()
print(int(b[2]), end=' ')
print(int(b[0]), end=' ')
print(int(b[1]), end=' ')

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

print(Z,X,Y)

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

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

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

Solution (Python):



def solve():
    print(str(z)+" "+str(x)+" "+str(y))
    return




x, y, z = [int(i) for i in input().split(" ")]
solve()

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

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

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

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

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

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

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

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

l_1 = []
l_1.append(l_0[1])
l_1.append(l_0[0])
l_1.append(l_0[2])

l_2 = []
l_2.append(l_1[2])
l_2.append(l_1[1])
l_2.append(l_1[0])

print('{} {} {}'.format(l_2[0],l_2[1],l_2[2]))

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

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

Solution (Python):


nim,mike,kite = (int(i) for i in input().split())
print(kite,nim,mike)

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

print(num[2], num[0], num[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=map(int,input().split())
print(z,x,y)

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

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

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

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

Solution (Python):
A,B,C = map(str,input().split())
print(C+' '+A+' '+B)

Solution (Python):

import sys
from collections import Counter
from itertools import permutations, combinations

from math import ceil, floor
import bisect
sys.setrecursionlimit(10 ** 6)
inf = float("inf")

def input():
    return sys.stdin.readline()[:-1]

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

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


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


if __name__ == '__main__':
    solve()

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

print(Z, X, Y)

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

print(Z, X, Y)

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

Solution (Python):

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


a = z
b = x
c = y


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

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

Solution (Python):


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

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

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

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

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

print(z, x, y)

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

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

a = n[0]
b = n[1]
c = n[2]

"aとbの入れ替え"
n[0] = b
n[1] = a
"aとcの入れ替え"
n[0] = c
n[2] = b

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

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

print(c,a,b)

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

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

tmp = num[2]
num[2] = num[0]
num[0] = tmp

print(*num)

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

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