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

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

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

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

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

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

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

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


main()

Solution (Python):
def main():
    X, Y, Z = list(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 = (int(x) for x in input().split())
temp1 = X
temp2 = Y
temp3 = Z
X = temp2
Y = temp1
X = temp3
Z = temp2
x = str(X)
y = str(Y)
z = str(Z)
print(x + ' ' + y + ' ' + z)

Solution (Python):
def main():

    x,y,z = tuple([int(t)for t in input().split()])

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

    print(x,y,z)


if __name__ == "__main__":
    main()

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

a2 = c
b2 = a
c2 = b
print('{} {} {}'.format(a2,b2,c2))

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

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

Solution (Python):




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

    x, y = y, x
    x, z = z, x
    print(' '.join(map(str, [x, y, z])))


if __name__ == '__main__':
    main()

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

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

if __name__ == '__main__':
    resolve()

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

Solution (Python):
x,y,z=map(int,input().split())
dx=x
dy=y
dz=z
x=dz
y=dx
z=dy
print("%d %d %d"%(x,y,z))

Solution (Python):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

A, B, C = read_int()
A, B = B, A
A, C = C, A
def solve():
    print("{a} {b} {c}".format(a=A, b=B, c=C))

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

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

Solution (Python):



from math import *
from copy import *
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l,m):
	f = 1
	n = len(l)
	tot = sum(l)
	k = tot/(4*m)
	l = sorted(l)[::-1][:m]
	for i in l:
		if(i < k):
			f = 0
			break
	if(f):
		return 'Yes'
	else:
		return 'No'

a,b,c = list(map(int, stdin.readline().rstrip().split()))
a,b = b,a
a,c = c,a
print(a,b,c)

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

a = z
b = x
c = y

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

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

X2, Y2, Z2 = Y, X, Z
X3, Y3, Z3 = Z2, Y2, X2

print(X3, Y3, Z3)

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

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

Solution (Python):
from sys import stdin


def get_result(data):
    X, Y, Z = data
    return str(Z) + ' ' + str(X) + ' ' + str(Y)


if __name__ == '__main__':
    data = list(map(int, stdin.readline().rstrip().split(' ')))
    result = get_result(data)
    print(result)

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


ints = list(map(int, input().split()))
ints[0], ints[1] = ints[1], ints[0]
ints[0], ints[2] = ints[2], ints[0]

print(" ".join([ str(e) for e in ints]))

Solution (Python):



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

print(Z, X, Y)

Solution (Python):
inp = input().split()
print(inp[2], inp[0], inp[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())
print(str(z) + " " + str(x) + " " + str(y))

Solution (Python):
from collections import defaultdict

import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

def main():
    x,y,z=mis()
    print(z,x,y,sep=' ')


if __name__ == "__main__":
    main()

Solution (Python):
data = input().split()
x = int(data[0])
y = int(data[1])
z = int(data[2])
print(z,x,y)

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

Solution (Python):
data = [i for i in input().split()]

print('{} {} {}'.format(data[2], data[0], data[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('{} {} {}'.format(X,Y,Z))

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

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

Solution (Python):
a = list(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(lambda x: int(x), input().split(" "))

print(Z, X, Y)

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

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

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

a = x
b = y
c = z

print(c, a, b)

Solution (Python):

import sys


def solve(X: int, Y: int, Z: int):
    print("{} {} {}".format(Z,X,Y))
    return



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

if __name__ == '__main__':
    main()

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

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

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

print(C,A,B)

Solution (Python):
number = input().split(" ")
A = int(number[0])
B = int(number[1])
C = int(number[2])
print(str(C) + " " + str(A) + " " + str(B))

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

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

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

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

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

tmp = X
X = Y
Y = tmp
tmp = Z
Z = X
X = 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):
A, B, C = map(int, input().split())
A_tmp = A
B_tmp = B
C_tmp = C
B = A
A= B_tmp
C = A
A = C_tmp
print(A, B, C)

Solution (Python):
a = input()

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

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


if __name__ == '__main__':
    main()

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

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

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


def main():
    x, y, z = map(str, input().split())
    temp = x
    x = y
    y = temp
    temp = x
    x = z
    z = temp
    print(x+' '+y+' '+z)


main()

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

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

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

print(z,x,y)

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

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

print(c,a,b)

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

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

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

Solution (Python):
def getInput():
    return [int(i) for i in input().rstrip().split(' ')]

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

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

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

Solution (Python):


import sys
import math

from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint

INF = float('inf')

ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
sys.setrecursionlimit(1000000000)


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



X,Y,Z = mis()
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(str(z)+' '+str(x)+' '+str(y))

Solution (Python):
[X,Y,Z] = [int(s) for s in input().rstrip().split(' ')]
print("{} {} {}".format(Z,X,Y))

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

Solution (Python):



def main():
    a, b, c = input().split(" ")
    print("%s %s %s" % (c, a, b))


if __name__ == '__main__':
    main()

Solution (Python):
X, Y, Z = map(int, input().split())
tmp = X
X = Y
Y = tmp
tmp = X
X = Z
Z = tmp
print(' '.join(map(str, [X, Y, Z])))

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

Solution (Python):
from sys import stdin


def get_result(data):
    X, Y, Z = data
    return str(Z) + ' ' + str(X) + ' ' + str(Y)


if __name__ == '__main__':
    data = list(map(int, stdin.readline().rstrip().split(' ')))
    result = get_result(data)
    print(result)

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

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

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

Solution (Python):
first = [int(i) for i in str(input()).split()]
a = first[0]
b = first[1]
c = first[2]

x = a
a = b
b = x

x = a
a = c
c = x

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

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

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

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

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

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

Solution (Python):

import math
import itertools
import statistics

import collections


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

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

Solution (Python):
def main():
  x, y, z = input().split()
  
  return z + ' ' + x + ' ' + y 

print(main())

Solution (Python):




if(__name__ == '__main__'):
    
    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 = [int(i) for i in 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(str(z)+' '+str(x)+' '+str(y))

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin
import math
import fractions

a, b, c = [int(x) for x in stdin.readline().rstrip().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())
a,b = y,x
a,c = z,a
print(a,b,c)

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

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


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

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

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

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

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

print(' '.join(numbers))

Solution (Python):

import sys


def solve(X: int, Y: int, Z: int):
    print(str(Z) + ' ' + str(X) + ' ' + str(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 = input().split(" ")

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

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

x = Z + ' ' + X + ' ' + Y

print(x)

Solution (Python):

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

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

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

Solution (Python):

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

print(Z, X, Y)

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

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

Solution (Python):
x, y, z = tuple(input().split(" "))
print("{} {} {}".format(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())
x =[]
x.append(Z)
x.append(X)
x.append(Y)
print(*x)

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

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

print(x,y,z);

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

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

print('%d %d %d' %(B,N,A))

Solution (Python):

from decimal import *
from itertools import permutations, combinations,combinations_with_replacement,product


s = input().split()
t = [int(p) for p in s]

X = t[0]
Y = t[1]
Z = t[2]

print('{} {} {}'.format(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())
l=x
x=z
m=y
y=l
z=m
a=[x,y,z]
print(*a)

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

S=[0]*3
S[0]=str(Z)
S[1]=str(X)
S[2]=str(Y)

print(' '.join(S))

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

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

Solution (Python):




import sys
input = sys.stdin.readline



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

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

    print(X,Y,Z)



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

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

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

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

Solution (Python):


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

Solution (Python):
def solve(x, y, z):
    return z, x, y


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


def test():
    assert solve(1, 2, 3) == (3, 1, 2)
    assert solve(100, 100, 100) == (100, 100, 100)


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

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

tmp =0
tmp = a[1]
a[1] = a[0]
a[0] = tmp
tmp = a[2]
a[2] = a[0]
a[0] = tmp

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

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

import sys


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



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

if __name__ == '__main__':
    main()

Solution (Python):


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

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

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

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

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

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

print(Z,X,Y)

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

m,n=n,m
m,l=l,m

print(m,n,l)

Solution (Python):
def main(x,y,z):
    return str(z)+" "+str(x)+" "+str(y)

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

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

tmp = x
x = y
y = tmp

tmp = x
x = z
z = tmp

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

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

Solution (Python):



from sys import stdin


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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
X,Y,Z=map(str,input().split())
print(Z+' '+X+' '+Y)

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    x,y,z=map(int, readline().rstrip().split())
    
    
    
    
    print(z,end="")
    print(" ",end="")
    print(x,end="")
    print(" ",end="")
    print(y)
    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

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

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

Solution (Python):
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""


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


if __name__ == '__main__':
    main()

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

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

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

print(z, x, y)

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

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

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

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

ABbox = 0
ACbox = 0

ABbox = X
X = Y
Y = ABbox

ACbox = X
X = Z
Z = ACbox

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

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

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 = [x for x in input().split()]
print("{} {} {}".format(z, x, y))

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

Solution (Python):


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

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

Solution (Python):
import string
def num():
    return int(input())
def nums():
    return list(map(int,input().split()))
X,Y,Z = nums()
X_copy = X
A = X
B = Y
C = Z
A = B
B = X_copy
C_copy = C
C = A
A = C_copy
print(A,B,C)

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

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

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

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

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

Solution (Python):


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


print("%s %s %s" % (x, y, z))

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

Solution (Python):
n,m,l=map(int,input().split())
print("{} {} {}".format(l,n,m))

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

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

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

print(X, Y, Z)

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

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

Solution (Python):
import sys
import numpy as np

import fractions
from collections import deque 
from functools import reduce

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

Solution (Python):
def solve(a,b,c):
  x = b
  y = a
  z = c
  return z, y, x

if __name__ == "__main__":
  _x, _y, _z = map(int,input().split())
  a,b,c = solve(_x,_y,_z)
  print(a,b,c)

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

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

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

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

import sys
nums = list(map(int, input().split()))
print('{} {} {}'.format(nums[2],nums[0],nums[1]))

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

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

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

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

print(z, x, y)

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

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

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

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

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

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

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

Solution (Python):
X, Y, Z = map(str,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())
tmp = x
x = y
y = tmp

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

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

print(Z, X, Y)

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

print(Z,X,Y)

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

Solution (Python):


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

w = Z
Z = X
X = w

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

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())
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().strip().split()))
print(Z, X, Y)