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:
# coding: utf-8
import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from heapq import heappop,heappush
import time
import os
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):#aはbの累乗数か
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def fac_list(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
#############################################

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# coding: utf-8
"""
about module
"""

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

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

Submission status: Accepted

Solution code:
import sys

if __name__ == "__main__":
    N, A, B = map(int,input().split())
    
    print(B, N, A)

Submission status: Accepted

Solution code:
a,sd,f=map(int,input().split())
print(f,a,sd)

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x,y,z = list(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:
def examA():
    X, Y, Z = LI()
    X, Y = Y,X
    X,Z = Z, X
    print(X,Y,Z)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**6)

if __name__ == '__main__':
    examA()

"""

"""

Submission status: Accepted

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

Submission status: Accepted

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

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict
from itertools import combinations, permutations
from itertools import accumulate
from math import ceil, sqrt, pi

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

Submission status: Accepted

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


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

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:
# coding: utf-8
# Your code here!
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:
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 = list(map(int,input().split()))

print(Z,X,Y)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
X, Y, Z = [int(x) for x in input().strip().split()]

print(Z, X, Y)

Submission status: Accepted

Solution code:
from sys import exit, setrecursionlimit
setrecursionlimit(10**6)

def array2D(row, col ,val=0):
    return [[val]*col for i in range(row)]

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

print(c,a,b)

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools
import heapq
#import bisect

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

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

print(c,a,b)

Submission status: Accepted

Solution code:
#!python3.4.3

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(Z, X, Y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#
# Written by NoKnowledgeGG @YlePhan
# ('ω')
#
#import math
#mod = 10**9+7
#import itertools
#import fractions
#import numpy as np
#mod = 10**4 + 7
"""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()

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

print(X, Y, Z)

Submission status: Accepted

Solution code:
def main():
    #from sys import stdin, setrecursionlimit
    #setrecursionlimit(10**9)
    #r = input()
    #n = int(input())
    #a, b = map(int, input().split())
    #s, y = input().split()
    #a = input().split()
    #a = list(map(int, input().split()))
    #a = [list(input().split()) for i in range(n)]
    #a = [int(input()) for i in range(n)]
    #a = [list(map(int, input().split())) for i in range(n)]
    #a = [int(s) - 1 for s in input().split()]
    #l=[int(input()) for _ in range(int(input()))]
    #res = 0
    x,y,z=map(int,input().split())
    print(z,x,y)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c = map(int,input().split())
print('{} {} {}'.format(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= list(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:
def main():
    x, y, z = (int(i) for i in input().split())
    print(z, x, y)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

print(z, x, y)

Submission status: Accepted

Solution code:
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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()
# print(main())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(z,x,y)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!python3

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

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
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()

Submission status: Accepted

Solution code:
import sys
import math
import collections
from collections import deque
import heapq
#n = int(input())
x, y, z = map(int, sys.stdin.readline().split())
#s = input()
#a = list(map(int, sys.stdin.readline().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=list(map(int, input().split()))
print (x[2],x[0],x[1])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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:
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:
#i=int(input())
#s=str(input())
#n,m=map(int, input().split())
#l=list(map(int, input().split()))
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:
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:
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)

Submission status: Accepted

Solution code:
# coding: utf-8

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)

Submission status: Accepted

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

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:
#!usr/bin/env python3
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)

Submission status: Accepted

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

print(Z,X,Y)

Submission status: Accepted

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

    #inf = 10**17
    #mod = 10**9 + 7

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
x, y, z = [int(i) for i in sys.stdin.readline().split()]
print(z, x, y)

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

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

Submission status: Accepted

Solution code:
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 LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')
 
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？


x,y,z=mii()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin,setrecursionlimit
li = list(map(int,stdin.readline().rstrip().split()))
print(li[2],li[0],li[1])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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)