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

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

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

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

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

Solution (Python):
X, Y, Z = map(int, input().split())
print(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 = (int(x) for x in 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_ = b
b_ = a

a__ = c
c_ = a_

print(a__, b_, c_)

Solution (Python):
tmp = 0

X,Y,Z = [int(e) for e in input().split(" ")]

tmp = Y

Y = X

X = 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):
n=input().split()
print(n[2],n[0],n[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())
x, y = y, x
x, z = z, x
print("{} {} {}".format(x, y, z))

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


temp = a
a = b
b = temp
temp = a
a = c
c = temp

print(a,b,c)

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

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

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

print(Z, X, Y)

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

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

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


print(a,b,c)

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

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


a = get()
print('{0} {1} {2}'.format(a[2], a[0], a[1]))

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

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

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

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

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

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

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

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

Solution (Python):
for _ in range(1):
	a,b,c = map(int,input().split())
	print(c,a,b)

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

nums = nums_raw[:]
nums[0] = nums_raw[1]
nums[1] = nums_raw[0]
nums_raw = nums[:]
nums[0] = nums_raw[2]
nums[2] = nums_raw[0]
print(" ".join(map(str, nums)))

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

tmp = [abc[0], abc[1], abc[2]]
abc[0] = tmp[1]
abc[1] = tmp[0]
abc[0] = tmp[2]
abc[2] = tmp[1]
abc = map(str, abc)
print(" ".join(abc))

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

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

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

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

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

Solution (Python):
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = sys.stdin.readline
    input_list = (lambda: input().rstrip().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

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


if __name__ == '__main__':
    main()

Solution (Python):

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

temp = y

y = x
x = temp

temp = z
z = x
x = temp

print(x,y,z)

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

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

a=i[2]
b=i[0]
c=i[1]
print(a,b,c)

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

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

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

Solution (Python):
xyz=list(map(int, input().split()))
x=xyz[0]
y=xyz[1]
z=xyz[2]
zxy=[z, x, y]
print(' '.join(map(str, zxy)))

Solution (Python):


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


a1 = a[0]
b1 = a[1]
c1 = a[2]


a2 = b1
b2 = a1
c2 = c1


a_fin = c2
b_fin = b2
c_fin = a2

print(str(a_fin)+" "+str(b_fin)+" "+str(c_fin))

Solution (Python):

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

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

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

if __name__ == '__main__':
    main()

Solution (Python):


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

Solution (Python):
a=list(input().split())
b=a[2]
del a[2]
a.insert(0,b)
print(' '.join(a))

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

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

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

t = x
x = y
y = t

t = x
x = z
z = t

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

Solution (Python):
a,b,c=map(int, input().split())
a2 = b
b2 = a
a3 = c
c3 = a2
print(str(a3)+' '+ str(b2)+' '+ str(c3))

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

li[0], li[1] = li[1], li[0]
li[0], li[2] = li[2], li[0]

for i in li:
    print(i, end=" ")

Solution (Python):
import sys

x, y, z = map(int, sys.stdin.readline().split())

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

if __name__ ==  '__main__':
    main()

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


def main(x, y, z):
    a, b, c = x, y, z
    a, b, c = b, a, c
    a, b, c = c, b, a
    print(a, b, c)


main(X, Y, Z)

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

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

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

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


temp = x
x = z
z = temp

temp = z
z = y
y = temp

print(x,y,z)

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

tmp = b
b = a
a = tmp

tmp = c
c = a
a = tmp

print(' '.join([str(a), str(b), str(c)]))

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

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

print(z, x, y)

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

Solution (Python):
A=[int(b) for b in input().split()]
B=A[:]
A[0]=B[2]
A[1]=B[0]
A[2]=B[1]
print(A[0], A[1], A[2])

Solution (Python):

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


T=A
A=B
B=T


T=A
A=C
C=T

print(A,B,C)

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

Solution (Python):
nums = input().split()
print(nums[2], *nums[:2])

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

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):
import sys
from io import StringIO
import unittest


def resolve():
    
    a, b, c = input().split()

    work = ""

    work = b
    b = a
    a = work

    work = c
    c = a
    a = work

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




class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """1 2 3"""
        output = """3 1 2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """100 100 100"""
        output = """100 100 100"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """41 59 31"""
        output = """31 41 59"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

Solution (Python):

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

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

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

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

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

Solution (Python):
import sys

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

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

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

Solution (Python):

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

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

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

a=X
b=Y
c=Z

aa=b
bb=a
aaa=c
cc=aa

print(aaa,bb,cc)

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

a, b, c = Z, X, Y

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

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

Solution (Python):
X,Y,Z=map(int,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 = [int(x) for x in input().split()]
print(a[2],a[0],a[1])

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

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

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

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

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



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


zxy = main()
print("{} {} {}".format(zxy[0], zxy[1], zxy[2]))

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

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

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

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

Solution (Python):

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

print(z,x,y)

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

if __name__ == "__main__":
    main()

Solution (Python):

data = input().split()

[data[0], data[1]] = [data[1], data[0]]

[data[0], data[2]] = [data[2], data[0]]

print(*data)

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

X = X^Y
Y = X^Y
X = X^Y

X = X^Z
Z = X^Z
X = X^Z

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

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

Solution (Python):
n=list(input().split())
nn=[]
nn.append(n[2])
nn.append(n[0])
nn.append(n[1])
result = ' '.join(nn)
print(result)

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

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("{} {} {}".format(C, A, B))

Solution (Python):
def swap(x, y):
    t = x
    x = y
    y = t
    return x, y

l = list(map(int, input().split()))
l[0], l[1] = swap(l[0], l[1])

l[0], l[2] = swap(l[0], l[2])

print(*l)

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

Solution (Python):





def solv(X, Y, Z):
    
    
    return " ".join([Z, X, Y])


if __name__ == "__main__":

    
    
    X, Y, Z = input().split()
    ans = solv(X, Y, Z)

    print(ans)

Solution (Python):


import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

def main():
    a, b, c = na()
    a, b = b, a
    a, c = c, a
    print(a, b, c)

if __name__ == "__main__":
    main()

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


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


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

wrk =0
wrk = a
a = b
b = wrk

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

Solution (Python):


A, B, C = map(lambda x: int(x), input().split(" "))

print("%d %d %d" % (C, A, B))

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

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

main()

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

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

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

a = X
b = Y
c = Z

X = c
Y = a
Z = b

print(X, Y, Z)

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

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

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

x, y = swap(x,y)
x, z = swap(x,z)

print(x,y,z)

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

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

Solution (Python):

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

x2=y
y2=x
x3=z
z2=x2

print(x3,y2,z2)

Solution (Python):

def resolve():
    a, b, c = map(int, input().split())
    a, b = b, a
    a, c = c, a
    return print(a, b, c)


if __name__ == "__main__":
    resolve()

Solution (Python):
a_0, b_0, c_0 = map(int, input().split()) 

a_1 = b_0
b_1 = a_0
c_1 = c_0

a_2 = c_1
b_2 = b_1
c_2 = a_1

print(a_2,b_2,c_2)

Solution (Python):


x, y, z = input().split()
print('{2} {0} {1}'.format(x, y, z))

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

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

line = "{0} {1} {2}".format(z, x, y)
print(line)

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

A = X
B = Y 
C = Z

temp = 0

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())
m = x
x = y
y = m

t = x
x = z
z = t

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

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

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

B=X
C=Y
A=Z

print(Z,X,Y)

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

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

print(z,x,y)

Solution (Python):
n=input()

abc = n.split(" ")

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

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

Solution (Python):
import sys
from math import sqrt
from collections import Counter, defaultdict

input = sys.stdin.readline


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


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


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    a, b, c = MI()
    print("{} {} {}".format(c, a, b))
    pass


if __name__ == "__main__":
    main()

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

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


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

Xa = Y
Ya = X
Xa = Z
Za = Y

print ( Z, X ,Y)

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

swap=0
swap=z
z=y
y=x
x=swap

print(x,y,z)

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("%d %d %d"%(z,x,y))

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

print(Z, X, Y)

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

print(Z, X, Y)

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


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

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

def swap(x, y):
    t = x
    x = y
    y = t
    return (x, y)

(x, y) = swap(x, y)
(x, z) = swap(x, z)

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(A,B,C)

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

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

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

def main():
    li = input().rstrip().split()
    ans = li[2]+' '+li[0]+' '+li[1]

    print(ans)

if __name__ == '__main__':
    main()

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

print(Z, X, Y)

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

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

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

print(x,y,z)

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

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

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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('{} {} {}'.format(c, a, b))

Solution (Python):

X,Y,Z = map(int,input().split())
L =[]
L.append(str(Z))
L.append(str(X))
L.append(str(Y))

print(" ".join(L))

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

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

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

A=X
B=Y
C=Z

A=Y
B=X

A=Z
C=Y

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

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

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

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

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

x, y, z = map(int, input().replace("\n","").split())

print(z,x,y)

Solution (Python):


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


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

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

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

Solution (Python):
import collections, math

local = False
if local:
    file = open("inputt.txt", "r")

def inp():
    if local:
        return file.readline().rstrip()
    else:
        return input().rstrip()

def ints():
    return [int(_) for _ in inp().split()]


X, Y, Z = ints()

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

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

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

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

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

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

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

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

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

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

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

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

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

print(X, Y, Z)

Solution (Python):
A = list(input().split(' '))
C =  [A[2], A[0], A[1]]

print(' '.join(C))

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



if __name__ == "__main__":
    main()

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

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

li1 = [c, a, b]

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

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

solution()

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

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

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (x, y, z) = [e for e in lines[0].split(' ')]

    return (x, y, z)


def solve(x, y, z):
    a, b, c = x, y, z 
    a, b, c = b, a, c
    a, b, c = c, b, a
    
    return ' '.join([a, b, c])
    


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

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

Solution (Python):
INT_MAX=10**18+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]

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

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

print (Z,X,Y)

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

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

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

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

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

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

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

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

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

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

x = A
A = B
B = x

x = A
A = C
C = x

print(A, B, C)

Solution (Python):

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

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

ans_list = [num_list[2], num_list[0], num_list[1]]
print(*ans_list)

Solution (Python):



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

print(c, a, b)

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())
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):
a, b, c = [int(x) for x in input().strip().split(" ")]
print(c, a, b)

Solution (Python):

def resolve():
    import sys
    input = sys.stdin.readline
    s = input().rstrip().split()
    print(s[2], s[0], s[1])
   
resolve()

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

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

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

Solution (Python):
from sys import stdin


def main():
    X, Y, Z = [int(x) for x in stdin.readline().rstrip().split()]
    print('{} {} {}'.format(Z, X, Y))


if __name__ == "__main__":
    main()

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

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

print(a,b,c)

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

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

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


wk = b
b  = a
a  = wk

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

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

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

print(A, B, C)

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

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

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

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

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

print(Z,X,Y)

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

Solution (Python):
x, y, z = map(int, input().split())
rep = x
x = y
y = rep
rep = x
x = z
z = rep
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):
def main():
    import sys
    input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

Solution (Python):
A,B,C=(int(x) for x in 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 = list(input().split())

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

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)