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

Submission status: Accepted

Solution code:
input_lists = list(input().split(' '))
result = [input_lists[-1]]
result += input_lists[0:-1]
result = ' '.join(result)
print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log, floor
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

x,y,z = MAP()

temp1 = x
x = y
y = temp1


temp2 = x
x = z
z = temp2

print(x,y,z)

Submission status: Accepted

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np
# sympy as syp(素因数分解とか)
Mod = 1000000007
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  #startline-------------------------------------------
    x, y, z = map(int, input().split())
    x, y = y, x
    x, z = z, x
    print(x,y,z)
if __name__ == "__main__":
    main() #endline===============================================

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
n = list(map(int,input().split()))
m = []
for i in range(2):
    m.append(n[0])
    n.pop(0)
    
n.append(m[0])
n.append(m[1])
  
print(*n)

Submission status: Accepted

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

print(f'{z} {x} {y}')

Submission status: Accepted

Solution code:
# A - ABC Swap
X,Y,Z = map(int,input().split())
print(Z,X,Y)

Submission status: Accepted

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

tmp = a
a = b
b = tmp

tmp = a
a = c
c = tmp

print(f"{a} {b} {c}")

Submission status: Accepted

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


#sys.setrecursionlimit(10**9)
#from functools import lru_cache

def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')


#import numpy as np

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





if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
n = list(map(int, input().split()))
     
x, y = (n[1], n[0])
n[0], n[1] = (x, y)
     
x, z = (n[2], n[0])
n[0], n[2] = (x, z)
     
print(" ".join(list(map(str, n))))

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(str(Z)+' '+str(X)+' '+str(Y))

Submission status: Accepted

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

Submission status: Accepted

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

print(Z,X,Y)

Submission status: Accepted

Solution code:
x,y,z = 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())
A,B,C = X,Y,Z
A,B = B,A
A,C = C,A
print('{} {} {}'.format(A,B,C))

Submission status: Accepted

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

main()

Submission status: Accepted

Solution code:
try:
    X_s,Y_s,Z_s = input().split(' ')
    X=int(X_s)
    Y=int(Y_s)
    Z=int(Z_s)
    
    if X>=1 and X<=100 and Y>=1 and Y<=100 and Z>=1 and Z<=100:
        
        A=X
        B=Y
        C=Z
        
        temp=B
        B=A
        A=temp
        
        temp=C
        C=A
        A=temp
        
        print(A,'',B,'',C)
        
except Exception as e:
    print(e)

Submission status: Accepted

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

Submission status: Accepted

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

tmp = A
A = B
B = tmp
tmp = A
A = C
C = tmp

print(A + " " + B + " " + C)

Submission status: Accepted

Solution code:
n = input().split()

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

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

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

Submission status: Accepted

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

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

ans = (" ").join([a, b, c])
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X,Y,Z = list(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,c=c,a,b
print(a,b,c)

Submission status: Accepted

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

Submission status: Accepted

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

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(f'{z} {x} {y}')

Submission status: Accepted

Solution code:
x, y, z = [int(i) for i in 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:
X,Y,Z = map(int,input().split())
G = X
X = Y
Y = G
G = X
X = Z
Z = G
print(f'{X} {Y} {Z}')

Submission status: Accepted

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

boxes[0], boxes[1] = boxes[1], boxes[0]
boxes[0], boxes[2] = boxes[2], boxes[0]

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

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

Submission status: Accepted

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

    print(f'{z} {x} {y}')
resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
*a, = map(int,input().split())
print("{} {} {}".format(a[2],a[0],a[1]))

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 = input().split()
 
# 箱Aと箱B入れ替え
list[0], list[1] = list[1], list[0]
 
# 箱Aと箱C入れ替え
list[0], list[2] = list[2], list[0]    
              
print(' '.join(list))

Submission status: Accepted

Solution code:
# [箱A, 箱B, 箱C]
list = input().split()

# 箱Aと箱B入れ替え
temp = list[0]
list[0] = list[1]
list[1] = temp

# 箱Aと箱C入れ替え
temp = list[0]
list[0] = list[2]
list[2] = temp              
              
print(' '.join(list))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print(c,a,b)

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:
combined = input().split(" ")
a = combined[0]
b = combined[1]
c = combined[2]

temp1 = b
b = a
a = temp1

temp2 = c
c = a
a = temp2

print(a, b, c)

Submission status: Accepted

Solution code:
import sys

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

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

Submission status: Accepted

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

A,B,C = Z,X,Y

print(A,B,C)

Submission status: Accepted

Solution code:

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

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

print(A,B,C)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print(*[z, x, y], sep=' ')

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())
print("{0} {1} {2}".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())

tmp = x
x = y
y = tmp

tmo = x
x = z
z = tmo

print(x, y, z)

Submission status: Accepted

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

#out = str(c)+" "+str(a)+" "+str(b)
print(c,a,b)

Submission status: Accepted

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

#out = str(c)+" "+str(a)+" "+str(b)
print(c,a,b)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys


if __name__ == '__main__':
    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:
l = input().split()
print(l[2], l[0], l[1])

Submission status: Accepted

Solution code:
# coding: utf-8
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)

Submission status: Accepted

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

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

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

print(Z,X,Y)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N=input().split()
X=N[0]
Y=N[1]
Z=N[2]

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

Submission status: Accepted

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

Submission status: Accepted

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


print(f"{z} {x} {y}")

Submission status: Accepted

Solution code:
# N = int(input())
X, Y, Z = [int(_) for _ 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:
x,y,z=map(int,input().split())
li=[z,x,y]
print(" ".join(map(str,li)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

p=x
x=y
y=p

p=x
x=z
z=p

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

Submission status: Accepted

Solution code:
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces
 
x, y, z = na()
print(z, x, y)

Submission status: Accepted

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

print(int(A), int(B), int(C))

Submission status: Accepted

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

A=[Z,X,Y]
print(*A,end='')

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

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

Submission status: Accepted

Solution code:
a = [int(i) for i in input().split()]
a[0], a[1] = a[1], a[0]
a[0], a[2] = a[2], a[0]
print(a[0], a[1], a[2])

Submission status: Accepted

Solution code:
a,b,c = map(str,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:
n = list(map(int,input().split()))
print(n[2],n[0],n[1])

Submission status: Accepted

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

print (C,A,B)

Submission status: Accepted

Solution code:
from sys import stdin, setrecursionlimit


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Submission status: Accepted

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

solve_A()

Submission status: Accepted

Solution code:
#A
x, y, z = [int(_) for _ in 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())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print("{} {} {}".format(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())

a=x
b=y
c=z

tmp=0

tmp=b
b=a
a=tmp
tmp=c
c=a
a=tmp

print(a,b,c)

Submission status: Accepted

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

print(C, A, B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# ABC161A

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

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

Submission status: Accepted

Solution code:
import sys
import heapq
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()

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

Submission status: Accepted

Solution code:
import sys
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
X,Y,Z = map(int, readline().split())
 
A,B,C = Z,X,Y
 
print(A,B,C)

Submission status: Accepted

Solution code:
def solve(string):
    x, y, z = map(int, string.split())
    return f"{z} {x} {y}"


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

Submission status: Accepted

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

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

Submission status: Accepted

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

d = int

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

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

Submission status: Accepted

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

import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug

import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect


if __name__ == '__main__':
    a, b, c = list(map(int, input().split()))
    a, b = b, a
    a, c = c, a
    print("{} {} {}".format(a, b, c))

    #print('\33[32m' + 'end' + '\033[0m') # debug

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    X, Y, Z = map(int, input().split())
    print(f"{Z} {X} {Y}")

Submission status: Accepted

Solution code:
def main():
    X,Y,Z = input().split()
    print(Z+" "+X+" "+Y)

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(str(X)+" "+str(Y)+" "+str(Z))

Submission status: Accepted

Solution code:
*s,c=input().split()
print(c,*s)

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

tmp = xyz[0]
xyz[0] = xyz[1]
xyz[1] = tmp

tmp = xyz[0]
xyz[0] = xyz[2]
xyz[2] = tmp

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

A = Y
B = X
A = Z
C = Y

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

w = x
x = y
y = w
w = x
x = z
z = w

print(x,y,z)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
import math
import fractions
import functools
x, y, z = map(int, input().split())
print(z,x,y)

Submission status: Accepted

Solution code:
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

# X, Y, Z => Y, X, Z => Z, X, Y

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:
values = input().split(' ')
print(' '.join((values[2], values[0], values[1])))

Submission status: Accepted

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

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

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

print(x, y, z)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x,y,z = list(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(str, input().split())
print(' '.join([Z, X, Y]))

Submission status: Accepted

Solution code:
from sys import stdin

X, Y, Z = stdin.readline().rstrip().split()
X, Y, Z = Z, X, Y
print(X, Y, Z)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

A, B, C = Y, X, Z
A, B ,C = C, B, A

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(X,Y,Z)

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

Submission status: Accepted

Solution code:
import sys
import os
import bisect, collections, copy, itertools, math, string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int, input().split()))
def LS(): return list(input().split())

def solve():
	ABC = LI()

	def swap(i, j):
		tmp = ABC[i]
		ABC[i] = ABC[j]
		ABC[j] = tmp

	swap(0, 1)
	swap(0, 2)

	print(ABC[0], ABC[1], ABC[2])
	
if __name__ == '__main__':
	solve()

Submission status: Accepted

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

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


if __name__ == '__main__':

    ABC_161_A()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
input = lambda: sys.stdin.readline().strip()

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

main()

Submission status: Accepted

Solution code:
a,b,c = input().split()
print(' '.join([c,a,b]))

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

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


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

print(c,a,b)

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

Submission status: Accepted

Solution code:
import sys
#from collections import defaultdict, deque, Counter
#from bisect import bisect_left
#import heapq
#import math
#from itertools import groupby as gb
#from itertools import permutations as perm
#from itertools import combinations as comb
#from fractions import gcd
#import numpy as np

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

#n = int(stdin.readline().rstrip())
#l = list(map(int, stdin.readline().rstrip().split()))
x,y,z = map(int, stdin.readline().rstrip().split())
#AB = [list(map(int, stdin.readline().rstrip().split())) for _ in range(n)]
print(z,x,y)

Submission status: Accepted

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

print(C, A, B, sep=' ')

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

print(z, x, y)

Submission status: Accepted

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

print(C + " " + A + " " + B)

Submission status: Accepted

Solution code:
val = input().split()
array = []
array.append(val[2])
array.append(val[0])
array.append(val[1])

print(' '.join(array))

Submission status: Accepted

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

A = X
B = Y
C = Z

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

print(A,B,C)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = input().split()

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

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

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

Submission status: Accepted

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

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:
import math
N = list(input().split())

N[0], N[1] = N[1], N[0]
N[0], N[2] = N[2], N[0]

print(' '.join(N))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A - ABC Swap

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)
#print("{} {}".format(z,x,y))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
a = z
b = x
c = y
L = [a,b,c]
print(' '.join(map(str,L)))

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

Submission status: Accepted

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

List=[X,Y,Z]

print(Z,X,Y)

Submission status: Accepted

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

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

print(X,Y,Z)

Submission status: Accepted

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

a = z
b = x
c = y

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