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

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

Solution (Python):
from sys import stdin
X,Y,Z = [int(x) for x in stdin.readline().rstrip().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 sys


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


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


if __name__ == "__main__":
    main()

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

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

print(Z, X, Y)

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

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

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

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

Solution (Python):



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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline

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

Solution (Python):
x, y, z = input().split()
print(' '.join([z, x, y]))

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

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math

import itertools
import heapq


import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)


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


if __name__ == "__main__":

    main()

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

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

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

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

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

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

print(z, x, y)

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


if __name__ == '__main__':
    main()

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

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

X,Y,Z = Z,X,Y

print(X,Y,Z)

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

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

print(c,a,b)

Solution (Python):


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

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

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

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

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

print(c, a, b)

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

Solution (Python):
a,b,c=(int(i) for i in 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):
import sys
readline = sys.stdin.readline

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

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

    print(a,b,c)

if __name__ == '__main__':
    main()

Solution (Python):










"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
  
def main():
  x,y,z = map(int,input().split())
  y,x = x,y
  x,z = z,x
  print(x,y,z)
if __name__ == '__main__':
  main()

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


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


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

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


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


if __name__ == "__main__":
    main()

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

print(X, Y, Z)

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

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

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

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

print(z, x, y)

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


if __name__ == '__main__':
    main()

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

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

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

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

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


if __name__ == '__main__':
    main()

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

print(Z, X, Y)

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)

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

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

print(z,x,y)

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

def 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 math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

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

main()

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

print(z,x,y)

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

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)

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

Solution (Python):
def main():
    import sys
    input=sys.stdin.readline
    x,y,z=map(int,input().split())
    print(z,x,y)
        
if __name__ == '__main__':
    main()

Solution (Python):
import math
def rMap():
	return map(int,input().split())
def rList():
	return list(map(int,input().split()))
x,y,z = rMap()
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):
import sys
X,Y,Z=map(int,input().split())
print(Z,X,Y)

Solution (Python):
import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
INF = 1 << 60
sys.setrecursionlimit(10 ** 6)


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):
import sys
input = sys.stdin.readline
from collections import *

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

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


iim = lambda: map(int, input().rstrip().split())

def resolve():
    A, B, C = iim()
    A, B = B, A
    A, C = C, A
    print(A, B, C)

if __name__ == "__main__":
    resolve()

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy


from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

def main():
    a,b,c = inpm()
    print(c,a,b)
    
if __name__ == "__main__":
    main()

Solution (Python):
import sys
import math
import collections
from collections import deque
import heapq

x, y, z = map(int, sys.stdin.readline().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())
x, y = y, x
x, z = z, x

print(x,y,z)

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

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

Solution (Python):
from sys import stdin

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

def intput():
	return int(input())

def sinput():
	return input().split()

def intsput():
	return map(int, sinput())

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y, Z = MAP()

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

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):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




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

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

print(z, x, y)

Solution (Python):

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

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

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

print(c, a, b)

Solution (Python):

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

print (Z,X,Y)

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

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

Solution (Python):
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("{} {} {}".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(x, y, z)

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

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

X, Y, Z = lr()
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())
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):
import sys
sys.setrecursionlimit(10 ** 7)

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

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

print(X, Y, Z)

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def PL(L) : print(*L, sep="\n")

X, Y, Z = LI()

print(Z, X, Y)

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

Solution (Python):
import sys

stdin = sys.stdin

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

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

Solution (Python):

import sys
import math
import string
import collections
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
import bisect

MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()

sys.setrecursionlimit(10 ** 8)

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

print(Z, X, Y)

Solution (Python):


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

print(Z,X,Y)

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

print(z, x, y)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    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):
def MI():return map(int,input().split())
def LI():return list(MI())

x,y,z=MI()

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

print(x,y,z)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

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

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd


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


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


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

if __name__ == '__main__':
    main()

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

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):
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())
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 sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 

sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

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

print(Z, X, Y)

Solution (Python):
mod = 10**9+7
import sys
from collections import Counter, defaultdict, deque
from itertools import product, permutations, combinations
from itertools import accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil,floor
from copy import deepcopy
from heapq import heappop,heappush,heapify
import heapq


sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1


p2D = lambda x: print(*x, sep="\n")

def II(): return int(sys.stdin.readline())

def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())




def LLI(rows_number): return [LI() for _ in range(rows_number)]


def LI(): return list(map(lambda x:int(x)*(-1), sys.stdin.readline().split()))
def HI(): return list(map(lambda x:int(x)*(-1), sys.stdin.readline().split()))


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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
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):
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):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






x,y,z=mii()

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

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

Solution (Python):
import sys

input = sys.stdin.readline

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

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

x, y, z = [int(x) for x in 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):
from sys import stdin,setrecursionlimit
li = list(map(int,stdin.readline().rstrip().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())
print(Z,X,Y)

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

Solution (Python):
import copy

import math
import fractions

def j(n):
    if n:print("Yes")
    else:print("No")
    exit(0)
rem = 10 ** 9 + 7

"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def ipmultiplerow(n):
    a = []
    for i in range(n):
        a.append(ip())
    return a
def printrow(a):
    for i in a:
        print(i)

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

x,y,z = ips()


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 array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

Solution (Python):

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

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

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

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

print(c, a, b)

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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy

sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


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

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

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


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


def main():

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


if __name__ == '__main__':
    main()

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

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

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

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

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