Problem:
Sorting Five Numbers Write a program which reads five numbers and sorts them in descending order. Input Input consists of five numbers a , b , c , d and e (-100000 ≤ a , b , c , d , e ≤ 100000). The five numbers are separeted by a space. Output Print the ordered numbers in a line. Adjacent numbers should be separated by a space. Sample Input 3 6 9 7 5 Output for the Sample Input 9 7 6 5 3

Solution (Python):
s = input()
s = s.split()
n = []

for i in s:
    n.append(int(i))

isSorted = False

while(not isSorted):
    isSorted = True
    for i in range(4):
        if n[i] < n[i + 1]:
            temp = n[i]
            n[i] = n[i + 1]
            n[i + 1] = temp
            isSorted = False

print(n[0],n[1],n[2],n[3],n[4])

Solution (Python):
n = map(int, raw_input().split())
n.sort(reverse=True)
for i in n:
    print i,

Solution (Python):
a = list(map(int, (input().split())))
a = sorted(a, reverse=True)
for i in range(4): print(a[i],end=' ')
print(a[4])

Solution (Python):
n = map(int, raw_input().split())
n.sort(reverse = True)
for i in range(len(n)):
    print(n[i]),
print

Solution (Python):
while True:
    try:
        print "%d %d %d %d %d" % tuple(sorted(list(map(eval,raw_input().split())),reverse=True))
    except EOFError: break

Solution (Python):




import sys

for s in sys.stdin:
  d = map(int , s.split())
  d.sort()
  d.reverse()
  for e in d:
    print e,

Solution (Python):
lis=list(map(int,input().split()))
lis.sort()
for i in range(4,-1,-1):
    if i!=4:
        print(" ",end="")

    print(lis[i],end="")

print("")

Solution (Python):
print(*sorted(list(map(int, input().split())))[::-1])

Solution (Python):
ls = map(int,raw_input().split())
ls.sort(reverse=True)
print " ".join(map(str,ls))

Solution (Python):
L=map(int,raw_input().split(" "))
print " ".join(map(str,sorted(L,reverse=True)))

Solution (Python):
def int_sort(num1, num2):
	return cmp(int(num1), int(num2))

n = raw_input()
a = n.split()
a = sorted(a, cmp=int_sort)
a = a[::-1]
print " ".join(a)

Solution (Python):
ls = sorted(map(int, raw_input().split()))
for i in ls[::-1]:
    print i,

Solution (Python):
for i in sorted(map(int,raw_input().split()))[::-1]:print i,

Solution (Python):
import sys

for input_line in sys.stdin:
    input_line = input_line.split()
    input_line = [int(char) for char in input_line]
    input_line.sort(reverse=True)
    input_line = [str(num) for num in input_line]
    print ' '.join(input_line)

Solution (Python):
import sys

a = input()
n = list(map(int, a.strip().split()))

n.sort()
n.reverse()

for i in range(len(n)):
    print(n[i], end="")
    if i < len(n)-1:
        print(" ", end="")

print()

Solution (Python):
x = map(int, raw_input().split())
x.sort()
x.reverse()
output = ''
for num in x:
	output += str(num) + ' '
print output.strip()

Solution (Python):
l=map(int,raw_input().split())
l.sort()
for i in l[::-1]:
    print i,
print

Solution (Python):
l = [int(i) for i in input().split()]
l.sort()
l.reverse()
print(' '.join([str(i) for i in l]))

Solution (Python):
from math import *
PI = 3.1415926535898
while True:
	try:
		n = map(int, raw_input().strip().split(' '))
		n.sort()
		ans = ""
		c = False
		for x in reversed(n):
			if c:
				ans += ' '
			c = True
			ans += str(x)
		print ans
	except EOFError:
		break

Solution (Python):
print(' '.join(map(str, sorted(map(int, input().split()), reverse=True))))

Solution (Python):
def sort(num):
   l = len(num)
   for i in range(0,l):
        for j in range(0,l-i-1):
            if num[j] < num[j+1]:
               temp = num[j]
               num[j] = num[j+1]
               num[j+1]=temp
   print(num[0],end='')
   for i in range(1,len(num)-1):
       print('',num[i],end='')
   print('',num[i+1])

a , b , c , d , e = map(int,input().split())
num = []
num.append(a)
num.append(b)
num.append(c)
num.append(d)
num.append(e)
sort(num)

Solution (Python):
import sys

line = sys.stdin.readline()
line = line.split(" ")
inp = []
for i in line:
    inp.append(int(i))
inp.sort()
inp.reverse()
for i in range(len(inp)):
    if i<len(inp)-1:
        print (inp[i], end=" ")
    else:
        print (inp[i])

Solution (Python):


a = map(int, raw_input().split(" "))
a.sort(reverse = True)
for val in a:
    print val,

Solution (Python):
l = [int(s) for s in raw_input().split()]
l = [str(s) for s in sorted(l, reverse=True)]
print ' '.join(l)

Solution (Python):
print(*sorted(map(int, input().split()), reverse=True))

Solution (Python):

nums = map(int, raw_input().split())
nums_sort = sorted(nums,reverse=True)
ans = " ".join(map(str,nums_sort))
print ans

Solution (Python):
print(*sorted(map(int, input().split()), reverse=True))

Solution (Python):


l = map(int, raw_input(). split())
l = sorted(l)
print l[4],l[3],l[2],l[1],l[0]

Solution (Python):
print(' '.join(map(str,sorted(list(map(int,input().split())))[::-1])))

Solution (Python):
a=sorted(map(int,raw_input().split()))[::-1]
print("%d %d %d %d %d"%tuple(a))

Solution (Python):


l = map(int, raw_input(). split())
l = sorted(l, reverse=True)
print("%d %d %d %d %d" % (l[0], l[1], l[2], l[3], l[4]))

Solution (Python):
A=[int(i) for i in input().split()]
A.sort(reverse=True)
print(" ".join(map(str,A)))

Solution (Python):


num = map(int, raw_input().split())
num.sort()
num = num[::-1]
for i in xrange(len(num)):
    print num[i],

Solution (Python):


l = map(int, raw_input(). split())
l.sort()
l.reverse()
for i in xrange(len(l)):
    print(l[i]),

Solution (Python):
A=list(map(int, input().split()))
A.sort()
A.reverse()
print(*A)

Solution (Python):


import sys

def merge(A, left, mid, right):
    n1 = mid-left
    n2 = right-mid
    L = [0]*(n1+1)
    R = [0]*(n2+1)
    for i in range(n1):
        L[i] = A[left+i]
    for i in range(n2):
        R[i] = A[mid+i]
    L[n1] = R[n2] = sys.maxint
    i = j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1

def mergeSort(A, left, right):
    if left+1 < right:
        mid = (left+right)/2
        mergeSort(A, left, mid)
        mergeSort(A, mid, right)
        merge(A, left, mid, right)

A = map(int, raw_input().split())
mergeSort(A, 0, 5)
print " ".join(map(str, A[::-1]))

Solution (Python):
numbers = list(map(int, input().split()))
numbers.sort()
numbers.reverse()
print(' '.join(map(str, numbers)))

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):
n=map(int,raw_input().split())
n.sort()
n.reverse()
n=map(str,n)
print(" ".join(n))

Solution (Python):
l = list(map(int, input().split()))
l.sort()
l.reverse()
sl = list(map(str, l))
print(" ".join(sl))

Solution (Python):
print(" ".join(map(str, reversed(sorted(map(int, input().split()))))))

Solution (Python):
s = input().split()
arr = [int(s[i]) for i in range(5)]
arr.sort(reverse=True)
for i in range(len(arr)):
    if i != len(arr)-1:
        print(arr[i], end=" ")
    else:
        print(arr[i])

Solution (Python):
print(' '.join(map(str, sorted(list(map(int, input().split())), reverse=True))))

Solution (Python):
data = raw_input().split(' ')
data = map(str, sorted(map(int, data))[::-1])
print ' '.join(data)

Solution (Python):

l = [int(e) for e in input().split()]
print(' '.join(str(e) for e in sorted(l, reverse=True)))

Solution (Python):
l = sorted(map(int, input().split()), reverse=True)
print(' '.join(map(str, l)))

Solution (Python):
x = map(int, raw_input().split(" "))

x.sort()

for i in range(5):
  print x[4-i],

Solution (Python):
numlist = [eval(item) for item in input().split()]
numlist.sort()
numlist.reverse()
for i in range(len(numlist)):
	print(numlist[i], end = '')
	if i != len(numlist) - 1:
		print(end = ' ')
print()

Solution (Python):
numlist = [eval(item) for item in input().split()]
numlist.sort()
numlist.reverse()
for i in range(len(numlist)):
    print(numlist[i], end = '')
    if i != len(numlist) - 1:
        print(end = ' ')
print()

Solution (Python):
n = [int(x) for x in input().split()]
print(*sorted(n, reverse=True))

Solution (Python):
print(' '.join(map(str, sorted(map(int, input().split()), reverse=True))))

Solution (Python):
print " ".join(map(str, sorted(map(int, raw_input().split()), reverse=True)))

Solution (Python):
print(' '.join(map(str, reversed(sorted(map(int, input().split()))))))

Solution (Python):
a = list(map(int,input().split()))
a.sort(reverse = True);

print(*a)

Solution (Python):
print ' '.join(map(str, sorted(map(int, raw_input().split()))[::-1]))

Solution (Python):
line = input().split()
print(' '.join(sorted(line, key=int, reverse=True)))

Solution (Python):
Num = list(map(int,input().split()))
Num.sort()
Num = Num[::-1]
for i in range(len(Num)):
    if i == len(Num)-1:
        print(Num[i])
    else:
        print(Num[i],end = ' ')

Solution (Python):
print(" ".join(list(map(str, sorted(list(map(int, input().split())), reverse=True)))))

Solution (Python):
if __name__ == '__main__':
    
    data = [int(x) for x in input().split(' ')]

    
    data.sort(reverse=True)

    
    print(*data)

Solution (Python):
a=sorted([int(i) for i in input().split()],reverse=True)
print(" ".join(map(str,a)))

Solution (Python):
a=sorted([int(i) for i in input().split()],reverse=True)
print(" ".join(map(str,a)))

Solution (Python):

A=[int(i) for i in input().split()]
A.sort()
print("{} {} {} {} {}".format(A[4],A[3],A[2],A[1],A[0]))

Solution (Python):
print(' '.join(map(str, sorted(list(map(int, input().split())), reverse=True))))

Solution (Python):


data = input()
n = [0]*5
n[0],n[1],n[2],n[3],n[4] = map(int,data.split(' '))

count = 0
while True:
    for i in range(len(n)-1):
        if n[i] < n[i+1]:
            tmp = n[i]
            n[i] = n[i+1]
            n[i+1] = tmp
    count += 1
    if count == 5:
        break

for i in range(len(n)-1):
    print(n[i],end=' ')

print(n[len(n)-1])

Solution (Python):
a=sorted([int(i) for i in input().split()],reverse=True)
print(" ".join([str(i) for i in a]))

Solution (Python):
a=sorted([int(i) for i in input().split()],reverse=True)
print(*a)

Solution (Python):
print(*sorted([int(i) for i in input().split()],reverse=True))

Solution (Python):
def to_i(e):
  return int(e)

l = map(to_i, raw_input().rstrip().split(" "))
l.sort()
l.reverse()

print "{} {} {} {} {}".format(l[0], l[1], l[2], l[3], l[4])

Solution (Python):
print(*sorted(map(int,input().split()))[::-1])

Solution (Python):
nums = list(map(int, input().split()))
nums.sort()
nums.reverse()
print(*nums)

Solution (Python):
m=map(int,input().split())
s = sorted(m)
s.reverse()
print(*s)

Solution (Python):
import sys
import math as mas

a=list(map(int,input().split()))
a.sort()
a.reverse()
print(*a)

Solution (Python):
import sys
import math as mas

print(*reversed(sorted(list(map(int,input().split())))))

Solution (Python):


import sys
import os

lst = list(map(int, input().split()))
lst.sort(reverse=True)

print(*lst)

Solution (Python):
a = [int(temp) for temp in input().split()]
a.sort(reverse = True)
a = [str(temp) for temp in a]
print(' '.join(a))

Solution (Python):


list = list(map(int,input().split(' ')))
list.sort(reverse = True);

print(*list)

Solution (Python):
import sys
from functools import reduce
l = sorted(map(int,sys.stdin.readline().rstrip().split(' ')))[::-1]
print(' '.join(map(str,l)))

Solution (Python):
def main():
    numbers = map(int, input().split())
    numbers = sorted(numbers, reverse=True)
    print(*numbers)

if __name__ == "__main__":
    main()

Solution (Python):
print(" ".join(map(str,sorted(map(int,input().split()))[::-1])))

Solution (Python):
l = list(map(int,input().split()))
l.sort(reverse=True)
l = [str(i) for i in l]
print(' '.join(l))

Solution (Python):
def sort(A):
    N=len(A)
    for i in range(N):
        for j in range(N-i-1):
            if A[j] < A[j+1]:
                temp=A[j+1]
                A[j+1]=A[j]
                A[j]=temp
    return A
A=list(map(int,input().split()))
print(" ".join(list(map(str,sort(A)))))

Solution (Python):
ls = list(map(int,input().split()))

ls.sort()
ls.reverse()
print(*ls)

Solution (Python):
print(*sorted(list(map(int, input().split())))[::-1])

Solution (Python):
print(" ".join(map(str, sorted(list(map(int, input().split())), reverse=True))))

Solution (Python):
ls = list(map(int, input().split()))
ls.sort()
ls.reverse()
print(*ls)

Solution (Python):
a = [int(i) for i in input().split()]
sort = sorted(a, reverse=True)
for i in range(5):
    if i == 4:
        print(sort[i])
    else:
        print(sort[i], end = " ")

Solution (Python):
user = input()
a = []
b = []
b = user.split()
for i in range(5):
    a.append(int(b[i]))
for j in range(4):
    for k in range(j+1, 5):  
        if a[j] < a[k]:
            tmp = a[j]
            a[j] = a[k]
            a[k] = tmp

for j in range(5):
    if j == 4:
        print(a[j])
    else:
        print(str(a[j]), end=" ")

Solution (Python):
def main():
    a = list(map(int, input().split()))
    a.sort(reverse = True)
    for x in range(len(a)):
        if x == len(a) - 1:
            print(a[x])
        else:
            print(a[x], end = " ")
if __name__ == "__main__":
    main()

Solution (Python):


import sys, math, os


PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
    sys.stdin = open("sample-input.txt", "rt")


print(' '.join([str(_) for _ in sorted([int(__) for __ in input().split()], reverse=True)]))

Solution (Python):
import sys

def SortingFiveNumbers():
    for line in sys.stdin:
        num=list(map(int,line.split()))
        
        num.sort()
        num.reverse()
        print(' '.join(map(str,num)))
        
            
                
    
SortingFiveNumbers()

Solution (Python):
print(' '.join(map(str, sorted(map(int, input().split()), reverse=True))))

Solution (Python):
print(*sorted(map(int,input().split()))[::-1])

Solution (Python):

if __name__ == '__main__':
    a = list(map(int,input().split()))
    a.sort(reverse = True)
    print(*a)

Solution (Python):


number_list = list(map(int, input().split()))
number_list.sort()
number_list.reverse()
print(' '.join(map(str, number_list)))

Solution (Python):
x=map(int,input().split())
y=sorted(x,reverse=True)
print(*y)

Solution (Python):

a=map(int,raw_input().split(" "))
a.sort(reverse=True)
for val in a:
	print val,

Solution (Python):
line = [int(i) for i in input().split()]
line.sort(reverse=True)
for i in range(5):
  print(line[i], end=" " if i != 4 else "\n")

Solution (Python):
def main():
    A = list(map(int,input().split()))
    A.sort()
    A.reverse()   
    print(*A)

if __name__ == '__main__':
    main()

Solution (Python):
a = list(map(int, input().split()))
a.sort()
a.reverse()
print(*a)

Solution (Python):
l = map(int,raw_input().split())
l.sort()
l.reverse()
l = list(map(str, l))
output = ' '.join(l)
print output

Solution (Python):
print(*sorted(map(int, input().split()))[::-1])

Solution (Python):
a=[int(i) for i in input().split()]
a.sort(reverse=True)
print(*a)

Solution (Python):
A = [int(i) for i in input().split()]
A.sort()
A.reverse()
print(A[0],A[1],A[2],A[3],A[4])

Solution (Python):
print(*sorted(map(int,input().split()))[::-1])

Solution (Python):
print(*reversed(sorted(map(int,input().split()))))

Solution (Python):
print(*sorted(list(map(int,input().split())))[::-1])

Solution (Python):
print(" ".join(map(str,sorted([int(i) for i in input().split()],reverse=True))))

Solution (Python):
print(" ".join(map(str, sorted(list(map(int, input().split())), reverse = True))))

Solution (Python):
print(" ".join(map(str,sorted(list(map(int, input().split())), reverse=True))))

Solution (Python):
print(" ".join(map(str,sorted(map(int,input().split()),reverse=True))))

Solution (Python):



a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):
a = map(int,raw_input().split())
a.sort()
a.reverse()
for i in range(len(a)):
  print a[i],

Solution (Python):
a = map(int,raw_input().split())
a.sort()
a.reverse()
for i in range(len(a)):
  print a[i],

Solution (Python):
list = map(int, raw_input().split())
list.sort(reverse=True)
for i in list:
    print i,

Solution (Python):
lst = map(int,raw_input().split())
lst.sort()
lst.reverse()
print lst[0],lst[1],lst[2],lst[3],lst[4]

Solution (Python):
for i in sorted(map(int,raw_input().split()),reverse=True):
    print i,

Solution (Python):
x = map(int, raw_input().split(' '))
x.sort()
for i in range(len(x)):
   print x[-(i+1)],

Solution (Python):



def datasets():
    s = raw_input().strip()
    yield [int(w) for w in s.split()]
    
def main():
    for ds in datasets():
        print ' '.join([str(n) for n in sorted(ds, reverse=True)])
        
if __name__ == '__main__':
    main()

Solution (Python):
print ' '.join(map(str,list(reversed(sorted(map(int,raw_input().split()))))))

Solution (Python):
print " ".join(map(str, sorted(map(int, raw_input().strip().split()), lambda x, y: y - x)))

Solution (Python):
for a in reversed(sorted(map(int,raw_input().split()))):print a,

Solution (Python):
print " ".join(map(str, sorted(map(int, raw_input().strip().split(" ")), lambda x , y: y - x)))

Solution (Python):
x = map(int, raw_input().split(' '))
x.sort()
for i in range(len(x)):
   print x[-(i+1)],

Solution (Python):
l = map(int, raw_input().strip().split(" "));
print " ".join(map(str, sorted(l, lambda x, y: y - x)));

Solution (Python):
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
from sys import stdin
gen = (int(s) for s in stdin.readline().split())
print(' '.join(str(i) for i in sorted(gen, reverse=True)))

Solution (Python):
x = map(int,raw_input().split(' '))
x.sort()
x.reverse()
output = ''
for val in x:
	output += str(val) + ' '
print output.strip()

Solution (Python):
'''
Created on Mar 22, 2013

@author: wukc
'''

from sys import stdin

a=map(int,stdin.readline().split())
a.sort()
print(" ".join(map(str,a[::-1])))

Solution (Python):

import sys




for line in sys.stdin:
    nums = map(int, line.split(' '))
    nums.sort(lambda x, y: cmp(y, x))

    print ' '.join(map(str, nums))

Solution (Python):
if __name__ == "__main__":
    a = map(int,raw_input().split())

    a.sort()
    a.reverse()
    for i in a:
        print i,

Solution (Python):
x = sorted(map(int, raw_input().split()), reverse=True)

for e in x:
    print e,
print

Solution (Python):
print ' '.join(map(str, sorted(map(int, raw_input().split()), reverse = True)))

Solution (Python):


line = raw_input()
l = map(int, line.strip().split())

l.sort()
l.reverse()
l = map(str, l)
out = ' '.join(l)
print out

Solution (Python):
l = [int(s) for s in raw_input().split()]
l = [str(s) for s in sorted(l, reverse=True)]
print ' '.join(l)

Solution (Python):
x=sorted(map(int, raw_input().split()))
for e in x[::-1]:
    print e,
print

Solution (Python):
x=sorted(map(int,raw_input().split()))[::-1]
for e in x:
    print e,
print

Solution (Python):
print " ".join(map(str,sorted(map(int,raw_input().split()))[::-1]))

Solution (Python):
for e in sorted(map(int,raw_input().split()))[::-1]:
    print e,

Solution (Python):
x=sorted(map(int,raw_input().split()))[::-1]
for e in x:
    print e,

Solution (Python):
x=sorted(map(int,raw_input().split()))[::-1]
for e in x:print e,

Solution (Python):
x=sorted(map(int,raw_input().split()))[::-1]
for e in x: print e,

Solution (Python):


import sys

lineNumber = 0


for line in sys.stdin.readlines():
    lineNumber += 1

    
    List = map(int, line.strip().split(" "))

    List.sort()

    print "%d %d %d %d %d" % (List[4], List[3], List[2], List[1], List[0])

Solution (Python):
a = map(int, raw_input().split())
a.sort()
a.reverse()
print " ".join(map(str, a))

Solution (Python):
print reduce(lambda x,y:x+y, map(lambda x:str(x)+' ', sorted(map(int, raw_input().split()))[::-1])).rstrip()

Solution (Python):
nums = map(int, raw_input().split())
nums.sort(reverse=True)
print " ".join(map(str, nums))

Solution (Python):
import string
print string.join(map(str, sorted(map(int, raw_input().split()), reverse=True)))

Solution (Python):
import string
print string.join(map(str, sorted(map(int, raw_input().split())))[::-1])

Solution (Python):
print ' '.join(map(str, sorted(map(int, raw_input().split())))[::-1])

Solution (Python):
print ' '.join([str(x) for x in sorted([int(x) for x in raw_input().split()])[::-1]])

Solution (Python):
print ' '.join(map(str, sorted(map(int, raw_input().split()))[::-1]))

Solution (Python):
ns = map(int, raw_input().split(" "))
count = 0
for loop in xrange(4):
	for i in xrange(4):
		if ns[i] < ns[i+1]:
			ns[i] , ns[i+1] = ns[i+1] , ns[i]
print ns[0],ns[1],ns[2],ns[3],ns[4]

Solution (Python):
import sys

for s in sys.stdin:
  arr = map(int, s.split(' '))
  arr = sorted(arr, reverse=True)
  arr = map(str, arr)
  print " ".join(arr)

Solution (Python):
print ' '.join(map(str, sorted(map(int, raw_input().split()), reverse=True)))

Solution (Python):
print(' '.join(map(str, sorted(map(int, input().split()), reverse=True))))

Solution (Python):
l = input().split(' ')
for i in range(5):
    l[i] = int(l[i])
l.sort(reverse = True)
print(l[0], l[1], l[2], l[3], l[4])

Solution (Python):

import math

a=list(map(int, input().split()))

a.sort()
a.reverse()
print(*a)

Solution (Python):
s = list(map(int, input().split()))
print(" ".join(map(str, sorted(s, reverse=True))))

Solution (Python):
s = list(map(int, input().split()))
s.sort(reverse = True)
print(*s)

Solution (Python):
lst = list(map(int, input().split()))
lst.sort(reverse=True)
print(*lst)

Solution (Python):
int_list = sorted(list(map(int,input().split()))) 
int_list.reverse() 
l = [str(a) for a in int_list] 
s = ' '.join(l) 
print(s)

Solution (Python):
*S, = map(int, input().split())
S.sort(reverse=1)
print(*S)

Solution (Python):
numList = list(map(int, input().split()))

numList.sort(reverse=True)

print(' '.join(map(str, numList)))

Solution (Python):
s = list(map(int,input().split()))
print(*sorted(s)[::-1])

Solution (Python):
a = list(map(int,input().split()))
a.sort(reverse = True)
print(a[0],a[1],a[2],a[3],a[4])

Solution (Python):
a = [ int(x) for x in input().strip().split() ]
a = sorted(a, reverse=True)
for i in range(len(a)):
    if i > 0:
        print(" ", end='')
    print(a[i], end='')
print()

Solution (Python):
while 1:
    try:
        n = (int(x) for x in input().split())
    except:break

    n = sorted(n,reverse=True)
    for i in range(5):
        if i :
            print(" ", end="")
        print(n[i],end="")
    print()

Solution (Python):
N = list(map(int, input().split()))
N.sort()

for i in range(5) :
    if(i != 4) :
        print(N[4 - i], end = " ")
    else :
        print(N[0])

Solution (Python):
L = [int(x) for x in input().split()]

L.sort(reverse=True)
print(" ".join(map(str,L)))

Solution (Python):
l = list(map(int, input().split()))
l.sort(reverse = True)
print(' '.join(map(str, l)))

Solution (Python):
s = list(map(int, input().split()))
s.sort(reverse=1)
for i in range(4):
    print(s[i], end=" ")
print(s[4])

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):
a,b,c,d,e=map(int,input().split())
list=[a,b,c,d,e]
list.sort()
list.reverse()
s = list
print(*s)

Solution (Python):
print(*sorted(map(int,input().split()))[::-1])

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):






import sys
import math


class mymath:
    
    pi = 3.14159265358979323846264338

    
    def pnum_eratosthenes(self, n):
        ptable = [0 for i in range(n+1)]
        plist = []

        for i in range(2, n+1):
            if ptable[i]==0:
                plist.append(i)
                for j in range(i+i, n+1, i):
                    ptable[j] = 1
        return plist

    
    def gcd(self, a, b):
        if b == 0:
            return a
        return self.gcd(b, a%b)

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

    
    def mul(self, A, B):
        ans = []
        for a in A:
            c = 0
            for j, row in enumerate(a):
                c += row*B[j]
            ans.append(c)
        return ans

mymath = mymath()


class output:
    
    def list(self, l):
        l = list(l)
        
        for i, num in enumerate(l):
            print(num, end="")
            if i != len(l)-1:
                print(" ", end="")
        print()

output = output()






















def get_input():
    N = []
    while True:
        try:
            
            N.append(int(input()))
        except EOFError:
            break
    return N

N = [int(x) for x in input().split()]
N = sorted(N)

S = ''

for i in N[::-1]:
    S += str(i)+' ' 

print(S[:-1])

Solution (Python):
input_list = list(map(int, input().split()))
input_list.sort(reverse=True)
print(' '.join(map(str, input_list)))

Solution (Python):
if __name__ == '__main__':

	print(*sorted(map(int,input().split()),reverse=True))

Solution (Python):
a = list(map(int, input().split()))
a.sort()
a.reverse()
for i in  range(5):
  if i == 4:
    print(a[i])
  else:
    print(a[i], "", end = "")

Solution (Python):
a,b,c,d,e = map(int, input().split())
while True:
  if a < b:
    b,a = a,b
  elif b < c:
    c,b = b,c
  elif c < d:
    d,c = c,d
  elif d < e:
    e,d = d,e
  else:
    print(a,b,c,d,e)
    break

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):
lst = map(int, raw_input().split())
lst.sort()
lst.reverse()
ans = str(lst[0])
for i in range(1, 5):
	ans = ans + ' ' + str(lst[i])
print ans

Solution (Python):
num_lst = list(map(int,input().split()))
print(*reversed(sorted(num_lst)),sep=' ')

Solution (Python):
lst = sorted(list(map(int, input().split())), reverse=True)
for i in range(len(lst)):
    if i != len(lst) - 1:
        print(lst[i], end = " ")
    else:
        print(lst[i])

Solution (Python):
a = list(map(int, input().split()))
a.sort()
print(*a[::-1])

Solution (Python):
a = []
a = [int(i) for i in input().split()]
a.sort(reverse=True)
b = " ".join([str(i) for i in a])
print(b)

Solution (Python):
a = list(map(int,(input().split())))
a = sorted(a,reverse=True)
for i in range(0,4):
    print(a[i],end=' ')
print(a[4])

Solution (Python):
print(*sorted([int(x) for x in input().split()])[::-1])

Solution (Python):
num = list(map(int, input().split()))

num.sort(reverse=True)

for i, n in enumerate(num):
    if i == len(num) - 1:
        print(n)
    else:
        print(str(n) + " ", end="")

Solution (Python):
a = sorted(list(map(int, input().split())), reverse=True)
print(' '.join(map(str, a)))

Solution (Python):
if __name__ == '__main__':
    a = list(map(int, input().split()))
    print(*sorted(a, reverse=True))

Solution (Python):
xs = sorted( [int(x) for x in input().split()] )[::-1]

print( ' '.join( [str(x) for x in xs] ) )

Solution (Python):
print(" ".join(str(e) for e in sorted(list(map(int,input().split())))[::-1]))

Solution (Python):
def run():
    numbers = sorted(list(map(int, input().split())), reverse=True)
    print(' '.join([str(n) for n in numbers]))

if __name__ == '__main__':
    run()

Solution (Python):
print(*sorted(list(map(int, input().split())),reverse=True))

Solution (Python):

s = list(map(int, input().split()))
print(*sorted(s,reverse=True))