import java.util.Arrays;
import java.util.Scanner;
import java.util.Vector;

public class StringSort {
    public static void main(String[] args) {
        //String ss[]={"9","2","20","22"};
        Scanner sc=new Scanner(System.in);
        Vector<String> v=new Vector<>();
        if(sc.hasNextLine()){
            String[] inputString=sc.nextLine().split("\\s+");
            for(String s: inputString ){
                v.add(s);
            }
        }
        sc.close();
        MyString mySs[]=new MyString[v.size()];
        for (int i = 0; i < v.size(); i++) {
            mySs[i]=new MyString(v.get(i));
        }
        Arrays.sort(mySs);
        System.out.print("最大数：");
        for (int i = 0; i < mySs.length; i++) {
            System.out.print(mySs[i].s);
        }
    }
}


class MyString implements Comparable<MyString>{
    public String s;
    public MyString(String s) {
        this.s = s;
    }

    @Override
    public int compareTo(MyString o) {
        if(o==null||o.s==null) {
            return 1;
        }
        String tmp1 = s+o.s;
        String tmp2 = o.s+s;
        return -tmp1.compareTo(tmp2);

    }
}

import java.util.Arrays;

public class Solution {
	public String PrintMinNumber(int[] numbers) {
	    if (numbers == null || numbers.length == 0)
	        return "";
	    int n = numbers.length;
	    String[] nums = new String[n];
	    for (int i = 0; i < n; i++)
	        nums[i] = numbers[i] + "";
	    Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
	    String ret = "";
	    for (String str : nums)
	        ret += str;
	    return ret;
	}
}

public class Solution {
    public Node initTree(int[] preOrder,int pstart,int pend,int[] inOrder,int instart,int inend){
        if(pstart>pend||instart>inend){
            return null;
        }
        int rootData=preOrder[pstart];
        Node head=new Node(rootData);
        int rootIndex=findIndexInArray(inOrder,rootData,instart,inend);
        int offSet=rootIndex-instart-1;
        Node left=initTree(preOrder,pstart+1,pstart+offSet+1,inOrder,instart,instart+offSet);
        Node right=initTree(preOrder,pstart+offSet+2,pend,inOrder,rootIndex+1,inend);
        head.left=left;
        head.right=right;
        return head;
    }
    private int findIndexInArray(int[] inOrder,int rootData,int instart,int inend){
        for(int  i=instart;i<=inend;i++){
            if(inOrder[i]==rootData){
                return i;
            }
        }
        return -1;

    }
    public  void postOrder(Node root){
        if(root!=null){
            postOrder(root.left);
            System.out.print(root.val+" ");
            postOrder(root.right);
        }
    }


    public static void main(String[] args) {
        int[] preOrder = {1,2,4,8,9,5,10,3,6,7};
        int[] inOrder = {8,4,9,2,10,5,1,6,3,7};
        Solution tree=new Solution();
        Node root=tree.initTree(preOrder,0,preOrder.length-1,inOrder,0,inOrder.length-1);
        tree.postOrder(root);

    }

}

class Solution {
    public int lastStoneWeightII(int[] stones) {
        /* 由于石头拿走还能放回去，因此可以简单地把所有石头看作两堆
         * 假设总重量为 sum, 则问题转化为背包问题：如何使两堆石头总重量接近 sum / 2
         */
        int len = stones.length;
        /* 获取石头总重量 */
        int sum = 0;
        for (int i : stones) {
            sum += i;
        }
        /* 定义 dp[i] 重量上限为 i 时背包所能装载的最大石头重量 */
        int maxCapacity = sum/2;
        int[] dp = new int[maxCapacity + 1];
        for (int i = 0; i < len; i++) {
            int curStone = stones[i];
            for (int j = maxCapacity; j >= curStone; j--) {
                dp[j] = Math.max(dp[j], dp[j-curStone] + curStone);
            }
        }
        return sum - 2 * dp[maxCapacity];
    }
}