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



Sample input:
1 2 3


Sample output:
3 1 2

Submission status: Accepted

Solution code:
mod = 10 ** 9 + 7
mod2 = 2 ** 61 + 1
from collections import deque
import heapq


def iip(listed):
    ret = [int(i) for i in input().split()]
    if len(ret) == 1 and not listed:
        return ret[0]
    return ret


def main():
    X, Y, Z = iip(True)
    print(Z, X, Y)

    #r = solve()
    #print(r)


def solve():
    N = iip(False)
    S = input()


#####################################################ライブラリ集ここから

def split_print_space(s):
    print(" ".join([str(i) for i in s]))


def split_print_enter(s):
    print("\n".join([str(i) for i in s]))


def koenai_saidai_x_index(sorted_list, n):
    l = 0
    r = len(sorted_list)
    if len(sorted_list) == 0:
        return False
    if sorted_list[0] > n:
        return False

    while r - l > 1:
        x = (l + r) // 2
        if sorted_list[x] == n:
            return x
        elif sorted_list[x] > n:
            r = x
        else:
            l = x
    return l


def searchsorted(sorted_list, n, side):
    if side not in ["right", "left"]:
        raise Exception("sideはrightかleftで指定してください")

    l = 0
    r = len(sorted_list)

    if n > sorted_list[-1]:
        # print(sorted_list)
        return len(sorted_list)
    if n < sorted_list[0]:
        return 0

    while r - l > 1:
        x = (l + r) // 2
        if sorted_list[x] > n:
            r = x
        elif sorted_list[x] < n:
            l = x
        else:
            if side == "left":
                r = x
            elif side == "right":
                l = x

    if side == "left":
        if sorted_list[l] == n:
            return r - 1
        else:
            return r

    if side == "right":
        if sorted_list[l] == n:
            return l + 1
        else:
            return l


def soinsuu_bunkai(n):
    ret = []
    for i in range(2, int(n ** 0.5) + 1):
        while n % i == 0:
            n //= i
            ret.append(i)
        if i > n:
            break
    if n != 1:
        ret.append(n)
    return ret


def conbination(n, r, mod, test=False):
    if n <= 0:
        return 0
    if r == 0:
        return 1
    if r < 0:
        return 0
    if r == 1:
        return n
    ret = 1
    for i in range(n - r + 1, n + 1):
        ret *= i
        ret = ret % mod

    bunbo = 1
    for i in range(1, r + 1):
        bunbo *= i
        bunbo = bunbo % mod

    ret = (ret * inv(bunbo, mod)) % mod
    if test:
        # print(f"{n}C{r} = {ret}")
        pass
    return ret


def inv(n, mod):
    return power(n, mod - 2)


def power(n, p, mod_=mod):
    if p == 0:
        return 1
    if p % 2 == 0:
        return (power(n, p // 2, mod_) ** 2) % mod_
    if p % 2 == 1:
        return (n * power(n, p - 1, mod_)) % mod_


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-


def main():
    x, y, z = input().split()
    print(" ".join([z, x, y]))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
a=Y
b=X
c=Z
d=a
e=c
a=e
c=d 
print(str(a)+" "+str(b)+" "+str(c))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)  # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1  # 入力した数字に1を引いたものを返す
print_list_in_2D = lambda x: print(*x, sep="\n")  # リストの要素を改行を挟んで表示する関数

# 入力を整数に変換して受け取る
def input_int(): return int(input())

def map_int_input(): return map(int, input())

MII = map_int_input

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

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())

# 入力全てを整数に変換したものの配列を受け取る
def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

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

# 2次元リスト化
def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

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

Submission status: Accepted

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


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys


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


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    solve(X, Y, Z)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def resolve():
    X, Y, Z = input().split()

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


resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

A, B = B, A
A, C = C, A

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

Submission status: Accepted

Solution code:
def main():

    A, B, C = map(int, input().split())
    return " ".join(map(str, [C, A, B]))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def A():
    X, Y, Z= map(int, input().split())
    print(Z, X, Y)
A()

Submission status: Accepted

Solution code:
m = map(int,raw_input().split())
m[0],m[1] = m[1],m[0]
m[0],m[-1] = m[-1],m[0]
print ' '.join([str(i) for i in m])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    x, y, z = input().split(' ')
    print(z, x, y)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# 1行、2変数を受け取るとき
X, Y, Z = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict
import math
N, X, Y = map(int, input().split(' '))
print(Y, N, X)

Submission status: Accepted

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

Submission status: Accepted

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

print(c,a,b)

Submission status: Accepted

Solution code:
from collections import defaultdict, deque
import sys
import heapq
import bisect
import itertools
import queue
import copy
import time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7

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

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

def inpl_str(): return list(sys.stdin.readline().split())

x, y, z = inpl_str()
print(z + ' ' + x + ' ' + y)

Submission status: Accepted

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

d = a
a = b
b = d

e = a
a = c
c = e

print (a,b,c)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
X,Y,Z = list(map(int,input().split()))


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

A, B = B, A
A, C = C, A
print(A, end=" ")
print(B, end=" ")
print(C, end=" ")

Submission status: Accepted

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

print(a,b,c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    a, b, c = tuple([int(i) for i in input().split()])

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
X = list(map(int, input().split()))
Y = [str(X[2]), str(X[0]), str(X[1])]
print(" ".join(Y))

Submission status: Accepted

Solution code:
l=list(map(int,input().split()))
ans=[l[2]]+[l[0]]+[l[1]]
print(" ".join(map(str,ans)))

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X,Y,Z = input().split()
print(Z + ' ' + X + ' ' + Y)

Submission status: Accepted

Solution code:
def resolve():
    x, y,z = map(int, input().split())
    a,b,c = x,y,z
    b=x
    a=y
    c=a
    a=z  
    print(a,b,c)
        
if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
input_line = input()
Line = input_line.split()
Line = [int(s) for s in Line]

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

Submission status: Accepted

Solution code:
input = raw_input

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

xx = x
x = z
z = xx

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

Submission status: Accepted

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    x, y, z = args[0].split()
    x, y = y, x
    x, z = z, x

    return ' '.join([x, y, z])


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import numpy as np
import itertools
import collections
from collections import deque

sys.setrecursionlimit(10**6)
readline = sys.stdin.readline

h = itertools.combinations_with_replacement
p = itertools.permutations

def main():
    # input
    A, B, C = map(int, input().split())
    tmp = B
    B = A
    A = tmp

    tmp = C
    C = A
    A = tmp

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print( C, A, B )

Submission status: Accepted

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

print(c, a, b)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
i = list(map(int, input().split())) 
X = i[0]
Y = i[1]
Z = i[2]

print(Z, X, Y)

Submission status: Accepted

Solution code:
(X, Y, Z) = tuple([int(s) for s in input().split()])
# print(calc(N, M, t))
print(' '.join([str(x) for x in [Z, X, Y]]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C=input().split()
print(" ".join([C,A,B]))

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
#ABC
#YXZ
#ZXY
print(Z, X, Y)

Submission status: Accepted

Solution code:
X, Y, Z  = map(int, input().split())
D = 0
D = X
X = Y
Y = D

D = X
X = Z
Z = D

print(X,Y,Z)

Submission status: Accepted

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

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

Submission status: Accepted

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

print(z,x,y)

Submission status: Accepted

Solution code:
# coding: utf-8
X, Y, Z = map(int, input().split())
print(Z, X, Y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
X1 = Y
Y1 = X
Z1 = X1
X1 = Z
print(X1,Y1,Z1)

Submission status: Accepted

Solution code:
import sys
import os

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

print(Z, X, Y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
x1 = x
y1 = y
z1 = z
x = z1
y = x1
z = y1
print(x, y, z)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys


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


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

    print(z, x, y)


if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

Submission status: Accepted

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

print(c,a,b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))

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

Submission status: Accepted

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

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

print(a,b,c)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X,Y,Z=map(int, raw_input().split())
X,Y=Y,X
X,Z=Z,X
print X,Y,Z

Submission status: Accepted

Solution code:
import sys
I=input().split()
print(I[2],I[0],I[1])

Submission status: Accepted

Solution code:
abc = input().split();
a,b,c = int(abc[0]),int(abc[1]),int(abc[2]);
print('{} {} {}'.format(c,a,b));

Submission status: Accepted

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

print(z,x,y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
a_=b
b_=a
a__=c
c_=a_
print(a__,b_,c_)

Submission status: Accepted

Solution code:
# AtCoder Beginner Contest 161: A (2020/04/04)
X, Y, Z = map(int, input().split())
print(Z, X, Y)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

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

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

print(X,Y,Z)

Submission status: Accepted

Solution code:

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

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

print (x, y, z)

Submission status: Accepted

Solution code:
#coding:utf-8

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

Submission status: Accepted

Solution code:
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

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

Submission status: Accepted

Solution code:
import sys

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

print(Z, X, Y)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
    return arr

arr = input().split()
arr = swap(arr, 0, 1)
arr = swap(arr, 0, 2)
print(" ".join(arr))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
(x,y,z) = list(input().split())
print(z+" "+x+" "+y)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(1000000)
input = sys.stdin.readline
INF = 2**62-1

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


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(X, Y, Z):
    X, Y = Y ,X
    X, Z = Z, X
    return X, Y, Z


def main():
    X, Y, Z = read_int_n()
    print(*slv(X, Y, Z))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

    print(z, x, y)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding : utf-8

s = input()
x, y, z = s.split()
print(z,x,y)

Submission status: Accepted

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



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

Submission status: Accepted

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

print(c, a, b)

Submission status: Accepted

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

print(z,x,y)

Submission status: Accepted

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

print(Z,X,Y)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A1,B1,C1 = map(int, input().split())

A = C1
B = A1
C = B1

print(A,B,C)

Submission status: Accepted

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

# X, Y, Z = 1, 2, 3

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

print(X, Y, Z)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)

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

print(Z, X, Y)

Submission status: Accepted

Solution code:
import sys
a,b,c=map(int,sys.stdin.readline().split())
a,b=b,a
a,c=c,a
print(a,b,c)

Submission status: Accepted

Solution code:
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = list(map(int, input().split()))
print("{} {} {}".format(C, A, B))

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
X, Y, Z = map(int, input().split())
print("{} {} {}".format(Z, X, Y))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

def input_multiple_number():
    return map(str, input().split())


X,Y,Z = input_multiple_number()

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'

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


main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

print(z,x,y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

def solve():
    A,B,C = map(int, input().split())
    A, B = B, A
    A, C = C, A
    res = ' '.join(map(str, [A,B,C]))
    return str(res)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
xyz=input().rstrip().split()
print(int(xyz[2]),end=" ")
print(int(xyz[0]),end=" ")
print(int(xyz[1]))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# A - ABC Swap
# 標準入力の取得
X,Y,Z = list(map(int, input().split()))

# 結果出力
print(Z, X, Y)

Submission status: Accepted

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

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

print(a,b,c)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
tmp = 0
tmp = x
x = y
y = tmp

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

Submission status: Accepted

Solution code:
def resolve():
    '''
    code here
    '''
    A, B, C = [item for item in input().split()]

    A, B = B, A
    A, C = C, A

    print(A, B, C)
if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    x, y, z = map(int, input().split())

    print(z, x, y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#  --*-coding:utf-8-*--

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print(*ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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))  # type: int
    Y = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    solve(X, Y, Z)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Apr  4 20:49:19 2020

@author: naoki
"""

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

print(C, A, B)

Submission status: Accepted

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

print(Z, X, Y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(z, x, y)