#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>

// Helper function to check if string comparison shows s1 > s2
bool isGreater(char* s1, char* s2) {
    return strcmp(s1, s2) > 0;
}

// Check if a string is a good binary string
bool isGood(char* str, int len) {
    int balance = 0;
    for (int i = 0; i < len; i++) {
        if (str[i] == '1') balance++;
        else balance--;

        if (balance < 0) return false;
    }
    return balance == 0;
}

// Structure to store substring information
typedef struct {
    int start;
    int end;
} Substring;

char* largestMagical(char* binString) {
    int len = strlen(binString);

    // Allocate result string
    char* result = (char*)malloc((len + 1) * sizeof(char));
    strcpy(result, binString);
    result[len] = '\0';

    // Find all maximal good substrings
    Substring* substrings = (Substring*)malloc(len * sizeof(Substring));
    int substringCount = 0;

    int i = 0;
    while (i < len) {
        int balance = 0;
        int start = i;
        int j = i;

        while (j < len) {
            if (result[j] == '1') balance++;
            else balance--;

            if (balance < 0) break;

            if (balance == 0) {
                // Found a complete good substring
                substrings[substringCount].start = start;
                substrings[substringCount].end = j;
                substringCount++;
                i = j + 1;
                break;
            }
            j++;
        }

        if (j >= len) break;
    }

    // Perform bubble sort style swapping
    bool swapped = true;
    while (swapped) {
        swapped = false;

        for (int idx = 0; idx < substringCount - 1; idx++) {
            int start1 = substrings[idx].start;
            int end1 = substrings[idx].end;
            int start2 = substrings[idx + 1].start;
            int end2 = substrings[idx + 1].end;

            // Check if they are adjacent
            if (end1 + 1 != start2) continue;

            int len1 = end1 - start1 + 1;
            int len2 = end2 - start2 + 1;

            // Create temporary strings for comparison
            char* substr1 = (char*)malloc((len1 + 1) * sizeof(char));
            char* substr2 = (char*)malloc((len2 + 1) * sizeof(char));

            strncpy(substr1, result + start1, len1);
            substr1[len1] = '\0';
            strncpy(substr2, result + start2, len2);
            substr2[len2] = '\0';

            // Create swapped version
            char* temp = (char*)malloc((len + 1) * sizeof(char));
            strcpy(temp, result);

            // Swap the substrings
            strncpy(temp + start1, substr2, len2);
            strncpy(temp + start1 + len2, substr1, len1);

            // Check if swapped version is good and greater
            if (isGood(temp, len) && isGreater(temp, result)) {
                strcpy(result, temp);

                // Update substring positions
                substrings[idx].start = start1;
                substrings[idx].end = start1 + len2 - 1;
                substrings[idx + 1].start = start1 + len2;
                substrings[idx + 1].end = start1 + len2 + len1 - 1;

                swapped = true;
            }

            free(substr1);
            free(substr2);
            free(temp);
        }
    }

    free(substrings);
    return result;
}

int main() {
    FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

    char* binString = readline();
    char* result = largestMagical(binString);

    fprintf(fptr, "%s\n", result);

    fclose(fptr);
    free(binString);
    free(result);

    return 0;
}

char* readline() {
    size_t alloc_length = 1024;
    size_t data_length = 0;
    char* data = malloc(alloc_length);

    while (true) {
        char* cursor = data + data_length;
        char* line = fgets(cursor, alloc_length - data_length, stdin);

        if (!line) {
            break;
        }

        data_length += strlen(cursor);

        if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
            break;
        }

        alloc_length <<= 1;
        data = realloc(data, alloc_length);

        if (!data) {
            data = '\0';
            break;
        }
    }

    if (data[data_length - 1] == '\n') {
        data[data_length - 1] = '\0';
        data = realloc(data, data_length);

        if (!data) {
            data = '\0';
        }
    } else {
        data = realloc(data, data_length + 1);

        if (!data) {
            data = '\0';
        } else {
            data[data_length] = '\0';
        }
    }

    return data;
}