#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

void print (int len, const int buf[]) {
    int i = 0;
    while (i < len && buf[i] == 0)
        ++i;
    if (i == len) {
        putchar('0');
    } else {
        do {
            putchar(buf[i++] + '0');
        } while (i < len);
    }
    putchar('\n');
}

int max_used_from (int from, const int used[]) {
    int i;
    for (i = from; i >= 0; --i)
        if (used[i])
            return i;
    return -1;
}

int max_used (const int used[]) {
    int i;
    for (i = 9; i >= 0; --i)
        if (used[i])
            return i;
    assert (!"empty used bitmap");
}

int min_used_from (int from, const int used[]) {
    int i;
    for (i = from; i <= 9; ++i)
        if (used[i])
            return i;
    return -1;
}

int min_used (const int used[]) {
    int i;
    for (i = 0; i <= 9; ++i)
        if (used[i])
            return i;
    assert (!"empty used bitmap");
}

void subtract(int len, const int over[], const int under[], int diff[]) {
    int carry = 0;
    for (int i = len - 1; i >= 0; --i) {
        int d = over[i] - carry - under[i];
        if (d >= 0) {
            diff[i] = d;
            carry = 0;
        } else {
            diff[i] = d + 10;
            carry = 1;
        }
    }
}

void update_output (int len, const int buf[], const int buf_diff[],
                    int *out_len, int output[], int output_diff[]) {
    // Test if buf_diff < output_diff
    int i;
    for (i = 0; i < len; ++i)
        if (buf_diff[i] != output_diff[i])
            break;

    if (i < len && buf_diff[i] < output_diff[i]) {
        *out_len = len;
        memmove(output, buf, len * sizeof(int));
        memmove(output_diff, buf_diff, len * sizeof(int));
    }
}

void update_output_under (int len, const int goal[], const int buf[],
                          int *out_len, int output[], int output_diff[]) {
    int buf_diff[len];
    subtract(len, goal, buf, buf_diff);
    update_output(len, buf, buf_diff, out_len, output, output_diff);
}

void update_output_over (int len, const int goal[], const int buf[],
                         int *out_len, int output[], int output_diff[]) {
    int buf_diff[len];
    subtract(len, buf, goal, buf_diff);
    update_output(len, buf, buf_diff, out_len, output, output_diff);
}

/* Finds the number with at most [num] different digits such that the
 * difference between [goal] and [output] is the minimum.
 *
 * num: number of different digits in output, 0 < num <= 10
 * len: length of the goal number
 * goal: array of size len, forall 0 <= i < len, 0 <= goal[i] < 10, and goal[0] > 0
 * out_len: number of digits in the output
 * output: array of size at least [len + 1]
 */
void NearestDigits (int num, int len, const int goal[],
                    int *out_len, int output[]) {
    assert(0 < num && num <= 10);
    assert(0 < len);

    {
        int used[10] = {0};
        for (int i = 0; i < len; ++i)
            used[goal[i]] = 1;
        int n = 0;
        for (int i = 0; i < 10; ++i)
            n += used[i];
        if (n <= num) {
            *out_len = len;
            memmove(output, goal, len * sizeof(int));
            return;
        }
    }

    int buf[len];
    int output_diff[len];

    if (goal[0] == 1 && num == 1) {
        // Special case 1: 99999 may be the closest to goal 1xxxxx
        *out_len = len /*- 1*/;
        output[0] = 0;
        for (int i = 1 /* - 1*/; i < len /*- 1*/; ++i)
            output[i] = 9;
        subtract(len, goal, output, output_diff);
    } else if (goal[0] == 9) {
        // Special case 2: 100000 or 111111 may be the closest to goal 9xxxxx
        *out_len = len + 1;
        if (num == 1) {
            // Special case 2a: only one digit available: 111111
            for (int i = 0; i <= len; ++i)
                output[i] = 1;

            int i, left = 1;
            for (i = len - 1; i >= 0; --i) {
                if (left >= goal[i]) {
                    output_diff[i] = left - goal[i];
                    left = 1;
                } else {
                    output_diff[i] = 10 + left - goal[i];
                    left = 0;
                }
            }
        } else {  // num > 1
            // Special case 2a: can use both 0 and 1: 100000
            output[0] = 1;
            for (int i = 1; i <= len; ++i)
                output[i] = 0;

            int i;
            for (i = 0; i < len; ++i)
                output_diff[i] = 9 - goal[i];
            for (i = len - 1; i >= 0 && output_diff[i] == 9; --i)
                output_diff[i] = 0;
            ++output_diff[i];
        }
    } else {
        // Generic initialization
        *out_len = 0;
        for (int i = 0; i < len; ++i)
            output_diff[i] = 9;
    }

    int used[10] = {0};
    int i, n;
    for (i = 0, n = num; i < len; ++i) {
        buf[i] = goal[i];

        // Two most common cases can be done greedily
        if (used[goal[i]])
            continue;
        if (n > 2) {
            used[goal[i]] = 1;
            --n;
            continue;
        }

        if (n == 2) {
            if (goal[i] > 0 && !used[9]) {
                // Possibility 1: pick one under and a nine
                buf[i] = goal[i] - 1;
                for (int j = i + 1; j < len; ++j)
                    buf[j] = 9;
                update_output_under(len, goal, buf, out_len, output, output_diff);
            }

            if (goal[i] < 9 && !used[0]) {
                // Possibility 2: pick one over and a zero
                buf[i] = goal[i] + 1;
                for (int j = i + 1; j < len; ++j)
                    buf[j] = 0;
                update_output_over(len, goal, buf, out_len, output, output_diff);
            }

            // Possibility 3-5: match goal[i], go to n == 1
            buf[i] = goal[i];
            used[goal[i]] = 1;
            --n;
            continue;
        } else {  // n == 1
            {
                // Possibility 3: match goal[i]
                used[goal[i]] = 1;

                // Find out how much longer we can get freely
                int j;
                for (j = i + 1; j < len && used[goal[j]]; ++j)
                    buf[j] = goal[j];

                if (j == len)
                    // should not happen: num == number_of_different_digits(goal)
                    return;

                // Possibility 3a: maximal number that's smaller than goal.
                int k = max_used_from(goal[j], used);
                if (k >= 0) {
                    buf[j] = k;

                    int m = max_used(used);
                    for (k = j + 1; k < len; ++k)
                        buf[k] = m;
                    update_output_under(len, goal, buf, out_len, output, output_diff);
                }

                // Possibility 3b: minimal number that's larger than goal.
                k = min_used_from (goal[j], used);
                if (k >= 0) {
                    buf[j] = k;

                    int m = min_used(used);
                    for (k = j + 1; k < len; ++k)
                        buf[k] = m;
                    update_output_over(len, goal, buf, out_len, output, output_diff);
                }
                used[goal[i]] = 0;
            }  // End of possibility 3

            if (goal[i] > 0) {
                // Possibility 4: take 1 lower here, find maximal
                buf[i] = goal[i] - 1;
                if (used[goal[i] - 1]) {
                    // Possibility 4a: number already covered, can use 9
                    for (int j = i + 1; j < len; ++j)
                        buf[j] = 9;
                    update_output_under(len, goal, buf, out_len, output, output_diff);
                } else {
                    // Possibility 4b: new number, choose filler from used
                    used[goal[i] - 1] = 1;
                    int k = max_used(used);
                    for (int j = i + 1; j < len; ++j)
                        buf[j] = k;
                    update_output_under(len, goal, buf, out_len, output, output_diff);
                    used[goal[i] - 1] = 0;
                }
            }  // End of possibility 4

            if (goal[i] < 9) {
                // Possibility 5: take 1 over here, find minimal
                buf[i] = goal[i] + 1;
                if (used[goal[i] + 1]) {
                    // Possibility 5a: number already covered, can use 0
                    for (int j = i + 1; j < len; ++j)
                        buf[j] = 0;
                    update_output_over(len, goal, buf, out_len, output, output_diff);
                } else {
                    // Possibility 5b: new number, choose filler from used
                    used[goal[i] + 1] = 1;
                    int k = min_used(used);
                    for (int j = i + 1; j < len; ++j)
                        buf[j] = k;
                    update_output_over(len, goal, buf, out_len, output, output_diff);
                    used[goal[i] + 1] = 0;
                }
            }  // End of possibility 5
            return;
        }  // n == 1
    }  // for i = 0 to len - 1
}  // void NearestDigits

int goal[1024];
int output[1024];

int main () {
    int num;
    while (scanf(" %d ", &num) == 1) {
        int len = 0, c;
        while (isdigit(c = getchar())) {
            if (len < 1023)
                goal[len++] = c - '0';
        }
        int out_len;
        NearestDigits (num, len, goal, &out_len, output);
        print(out_len, output);
    }
    return 0;
}