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:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *


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


if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    print(str(a[2]) +" " + str(a[0])+" "+str(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())

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

print(a,b,c)

Submission status: Accepted

Solution code:
InputIntList = lambda : list(map(int, input().split()))
InputStrList = lambda : list(input().split())


x, y, z = InputIntList()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    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:
X, Y, Z = input().split(" ")
print(Z, X, Y)

Submission status: Accepted

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

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


x,y,z = [int(i) for i in read().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())
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())
a_ = b
b = a
a = a_
a_ = c
c = a
a = 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:
a, b, c = input().split(" ")

print(c, a, b)

Submission status: Accepted

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

#ss= []
#for i in range(n):
#    ss.appned(int(input()))

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:
A,B,C = [int(i.strip()) for i in input().split(' ')]

print(C,A,B)

Submission status: Accepted

Solution code:
x,y,z=[int(e) for e in 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:
import sys
def input():
    return sys.stdin.readline()[:-1]
a,b,c = map(int,input().split(' '))
print(c,a,b)

Submission status: Accepted

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

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

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

Submission status: Accepted

Solution code:
# n = int(input())
# s = input()
a,b,c = map(int,input().split())
# da = list(map(int,input().split()))
# a = [int(input()) for i in range(n)]
# da = [list(map(int,input().split())) for i in range(m)]

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
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:
l = [int(x)for x in input().split(' ')]
print(l[2],l[0],l[1])

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

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x



if __name__ == '__main__':
    X, Y, Z = mulinputs()

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

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

print(x,y,z)

Submission status: Accepted

Solution code:
#coding: utf-8

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

Submission status: Accepted

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

import sys
from itertools import accumulate

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

a, b, c = MAP()

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

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


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

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

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# N = int(input())
A,B,C = map(int,input().split())
# S = input()
# X1_list = [int(input()) for i in range(N)]
# X2_list = [list(map(int,input().split())) for i in range(N)]
print(C,A,B)

Submission status: Accepted

Solution code:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()


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 = [int(i) for i in 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:
hoge = input().split()

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]

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

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

Submission status: Accepted

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

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

print(three, one,two)

Submission status: Accepted

Solution code:
[X,Y,Z] = list(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)
main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq


MOD = 1000000007


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd(a, b)


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def is_prime(n):
    if n == 1:
        return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True


def main():
    A, B, C = get_inputs(int)
    print("{} {} {}".format(C, A, B))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect
#pypyではscipy, numpyは使えない
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson, minimum_spanning_tree
#from scipy.sparse import csr_matrix, coo_matrix, lil_matrix
#import numpy as np
from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7

def main():
  x, y, z = map(int, readline().split())
  print(z, x, y)
  
  
if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
def main():
    A = list( map( int, input().split()))
    print(A[2], A[0], A[1])
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#A
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= (int(i) for i in input().split())
#B = [int(x) for x in stdin.readline().rstrip().split()]
#A = [[int(i) for i in input().split()] for i in range(N)]

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

print(X, Y, Z)

Submission status: Accepted

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


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

Submission status: Accepted

Solution code:
import sys
import heapq
from operator import itemgetter
 
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a = IL()
print(a[2],a[0],a[1])

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

def ri():
    return int(input())

def rl():
    return list(input().split())

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

def check(s):
    for i in range(len(s)):
        if s[i] != s[len(s)-1-i]:
            return False
    return True

def main():
    x, y, z = rli()
    print(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:
A, B, C = 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:
x, y, z = (int(i) for i in input().split())
print(z, x, y)

Submission status: Accepted

Solution code:
import sys
from math import ceil, floor
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

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 = map(str, 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 = map(int, raw_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:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    x, y, z = map(int, rl().split())
    print(z, x, y)


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	S = LI()
	S[0],S[1]=S[1],S[0]
	S[0],S[2]=S[2],S[0]
	printH(S)

if __name__ == '__main__':
	main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

print(c,a,b)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
def main():
  # import bisect
  # from collections import Counter
  # from collections import defaultdict
  # from collections import deque
  # from copy import deepcopy
  # from fractions import gcd
  # from heapq import heappop,heappush
  # from itertools import accumulate
  # from itertools import combinations
  # from itertools import permutations
  # from itertools import product
  # from math import ceil,floor, pi
  import sys
  sys.setrecursionlimit(10**6)
  readline = sys.stdin.readline
  ints = lambda: map(int, readline().split())
  floats = lambda: map(float, readline().split())
  pyes = lambda: print("Yes")
  pno = lambda: print("No")
  lli = lambda I, J: [[0] * J for _ in range(I)]
  mod = 10**9+7

  x,y,z = ints()
  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:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
ZIP = lambda: zip(*(MAP() for _ in range(n)))

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


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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

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

X, Y, Z = Z, X, Y
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:
import bisect,sys
import math
from collections import deque

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


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


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % mod) % mod
        
    return CONV()



sys.setrecursionlimit(200005)

def main():
    X,Y,Z = isRaw()
    ans = " ".join([str(a) for a in [Z,X,Y]])
    return ans

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Submission status: Accepted

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

resolve()

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

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

Submission status: Accepted

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

print(z, x, y)

Submission status: Accepted

Solution code:
from collections import deque
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint

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

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col):
    data.sort(key=lambda x:x[col],reverse=False)
    return data

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

Submission status: Accepted

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

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

x, y, z = get_ints()
print('%d %d %d' % (z, x, y))

Submission status: Accepted

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

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

print(c,a,b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    x, y, z = LI()
    print(z, x, y)

main()

Submission status: Accepted

Solution code:
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:input()

"""========main code==============="""

x,y,z=ml()
x,y=y,x
x,z=z,x
print(x,y,z)
"""for _ in range(t):
    x=ii()"""
    #a=ll()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys, re, os
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
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 S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a, b, c = MAP()

print(c, a, b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    a,b,c= map(int, sys.stdin.readline().split(' '))
    print(c,a,b)
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Accepted

Solution code:
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

a,b,c = nm()

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

Submission status: Accepted

Solution code:
#AtCoder
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
sys.setrecursionlimit(10 ** 7)

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

Submission status: Accepted

Solution code:
import sys

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

      return 0

if __name__ == "__main__":
      solve()

Submission status: Accepted

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


if __name__ == '__main__':
    main()

# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())

Submission status: Accepted

Solution code:

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


print(Z,X,Y)