You are given a ternary string (it is a string which consists only of characters '0', '1' and '2').

You can swap any two adjacent (consecutive) characters '0' and '1' (i.e. replace "01" with "10" or vice versa) or any two adjacent (consecutive) characters '1' and '2' (i.e. replace "12" with "21" or vice versa).

For example, for string "010210" we can perform the following moves: 

  * "010210" → "100210"; 
  * "010210" → "001210"; 
  * "010210" → "010120"; 
  * "010210" → "010201". 



Note than you cannot swap "02" → "20" and vice versa. You cannot perform any other operations with the given string excluding described above.

You task is to obtain the minimum possible (lexicographically) string by using these swaps arbitrary number of times (possibly, zero).

String a is lexicographically less than string b (if strings a and b have the same length) if there exists some position i (1 ≤ i ≤ |a|, where |s| is the length of the string s) such that for every j < i holds a_j = b_j, and a_i < b_i.

Input

The first line of the input contains the string s consisting only of characters '0', '1' and '2', its length is between 1 and 10^5 (inclusive).

Output

Print a single string — the minimum possible (lexicographically) string you can obtain by using the swaps described above arbitrary number of times (possibly, zero).

Examples

Input

100210


Output

001120


Input

11222121


Output

11112222


Input

20


Output

20
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import static java.lang.Math.log;
import static java.lang.Math.min;

public class Solution2 {

    //------------------------------------------CONSTANTS---------------------------------------------------------------
    public static final int MOD = (int) (1e9 + 7);

    //---------------------------------------------I/0------------------------------------------------------------------

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(
                    new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }

        long nextLong() { return Long.parseLong(next()); }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static void print(String s) {
        System.out.println(s);
    }

    public static void main(String[] args) {
        FastReader sc = new FastReader();

        int t = 1;
        //t = sc.nextInt();

        for(int i = 0; i<t; i++) {
            System.out.println(solve(sc));
        }
    }

    //------------------------------------------------SOLVE-------------------------------------------------------------

    public static String solve(FastReader sc) {
        String s = sc.next();

        StringBuilder r = new StringBuilder("");
        int oC = 0;
        for (int i = 0; i<s.length(); i++) {
            if (s.charAt(i)!='1') {
                r.append(s.charAt(i));
            } else {
                oC++;
            }
        }

        int j = 0;

        StringBuilder ones = new StringBuilder("");
        while (oC>0) {
            ones.append('1');
            oC--;
        }

        boolean went = false;
        while (j<r.length()) {
            if (r.charAt(j)=='0') {
                j++;
            } else {
                r.insert(j, ones);
                went = true;
                break;
            }

        }

        if (!went) {
            r.append(ones);
        }

        return r.toString();
    }

    //-----------------------------------------------FUNCTIONS----------------------------------------------------------

    public static void printArray(int[] a) {
        for(int i = 0; i<a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    // first element that is not less than target
    public static int lowerBound(int[] arr, int begin, int end, int target) {
        while(begin < end) {
            int mid = begin + (end - begin) / 2;
            // When the element is less than the mid target
            if(arr[mid] < target)
                // begin to mid + 1, arr [begin] value is less than or equal target
                begin = mid + 1;
                // When the mid target element when greater than or equal
            else if(arr[mid] >= target)
                end = mid;
        }
        return begin;
    }

    // first element that is greater than target
    public static int upperBound(int[] arr, int begin, int end, int target) {
        while(begin < end) {
            int mid = begin + (end - begin) / 2;
            if(arr[mid] <= target)
                begin = mid + 1;
            else if(arr[mid] < target)
                end = mid;
        }
        return begin;
    }

    // generate permutations (call search and access through permutations)
    public static class Permutations {
        List<List<Integer>> permutations = new ArrayList<>();
        List<Integer> permutation = new ArrayList<>();
        boolean[] taken;
        int[] a;

        public Permutations(int[] a) {
            this.a = a;
            taken = new boolean[a.length];
        }

        void search() {
            if (permutation.size()==a.length) {
                permutations.add(new ArrayList<>(permutation));
            } else {
                for (int i = 0; i<a.length; i++) {
                    if (taken[i]) {
                        continue;
                    }
                    taken[i] = true;
                    permutation.add(a[i]);
                    search();
                    taken[i] = false;
                    permutation.remove(permutation.size()-1);
                }
            }
        }
    }

    // generate subsets (call search and access subsets)
    public static class Subsets {
        List<List<Integer>> subsets = new ArrayList<>();
        List<Integer> subset = new ArrayList<>();

        void search(int[] a, int x) {
            if (x == a.length) {
                subsets.add(new ArrayList<>(subset));
            } else {
                subset.add(a[x]);
                search(a, x+1);
                subset.remove(subset.size() - 1);
                search(a, x+1);
            }
        }
    }

    public static int[] prefixSum(int[] a) {
        int n = a.length;
        int[] ps = new int[n];
        ps[0] = a[0];

        for (int i = 1; i<n; i++) {
            ps[i] = ps[i-1] + a[i];
        }

        return ps;
    }

    public static int[][] prefixSum2D(int[][] a) {
        int n = a.length;
        int m = a[0].length;
        int[][] ps = new int[n][m];
        ps[0][0] = a[0][0];

        for (int j = 1; j<m; j++) {
            ps[0][j] = ps[0][j-1] + a[0][j];
        }
        for (int i = 1; i<n; i++) {
            ps[i][0] = ps[i-1][0] + a[i][0];
        }

        for (int i = 1; i<n; i++) {
            for (int j = 1; j<m; j++) {
                ps[i][j] = ps[i-1][j] + ps[i][j-1] - ps[i-1][j-1] + a[i][j];
            }
        }

        return ps;
    }

    public static double log2(double a) {
        return log(a)/log(2);
    }

    //----------------------------------------DATA-STRUCTURES-----------------------------------------------------------

    // Range queries (i.e. RMQ) in O(1), others with functions in O(log n)
    public static class SparseTable {
        int[][] st;
        int n;
        int k;

        public SparseTable(int[] a) {
            n = a.length;
            k = (int) log2(n);
            st = new int[n][k+1];

            for (int i = 0; i<n; i++) {
                st[i][0] = a[i];
            }

            // 1<<j == 2^j
            for (int j = 1; j<=k; j++) {
                for (int i = 0; i + (1 << j) <= n; i++) {
                    st[i][j] = min(st[i][j-1], st[i + (1 << (j - 1))][j - 1]);
                }
            }
        }

        //not always available O(log n) -- change the constructor to use it
        public long sumQuery(int l, int r) {
            long sum = 0;
            for (int j = k; j>=0; j--) {
                if ((1 << j) <= r - l + 1) {
                    sum += st[l][j];
                    l += 1 << j;
                }
            }

            return sum;
        }

        //always available O(1) -- change this and the constructor for rangeMaxQuery
        public int rangeMinQuery(int l, int r) {
            int j = (int) log2(r - l + 1);
            int min = min(st[l][j], st[r - (1 << j) + 1][j]);
            return min;
        }

    }

    public static class BinaryIndexedTree {

        int[] bit;

        public BinaryIndexedTree(int[] a) {
            int n = a.length;
            bit = new int[n+1];
            // Store the actual values in BITree[]
            // using update()
            for(int i = 0; i < n; i++)
                updateBit(i, a[i]);
        }

        // O(log n) update delta at index in the array (do it on the array and then call this function)
        public void updateBit(int index, int delta) {
            index += 1;

            while (index <= bit.length) {
                bit[index] += delta;

                index += index & (-index);
            }
        }

        // Computes sum a[0...index] in O(log n)
        public int getSum(int index) {
            int sum = 0;

            index += 1;

            while (index > 0) {
                sum += bit[index];

                index -= index & (-index);
            }

            return sum;
        }
    }
}