And where the are the phone numbers?

You are given a string s consisting of lowercase English letters and an integer k. Find the lexicographically smallest string t of length k, such that its set of letters is a subset of the set of letters of s and s is lexicographically smaller than t.

It's guaranteed that the answer exists.

Note that the set of letters is a set, not a multiset. For example, the set of letters of abadaba is {a, b, d}.

String p is lexicographically smaller than string q, if p is a prefix of q, is not equal to q or there exists i, such that pi < qi and for all j < i it is satisfied that pj = qj. For example, abc is lexicographically smaller than abcd , abd is lexicographically smaller than abec, afa is not lexicographically smaller than ab and a is not lexicographically smaller than a.

Input

The first line of input contains two space separated integers n and k (1 ≤ n, k ≤ 100 000) — the length of s and the required length of t.

The second line of input contains the string s consisting of n lowercase English letters.

Output

Output the string t conforming to the requirements above.

It's guaranteed that the answer exists.

Examples

Input

3 3
abc


Output

aca


Input

3 2
abc


Output

ac


Input

3 3
ayy


Output

yaa


Input

2 3
ba


Output

baa

Note

In the first example the list of strings t of length 3, such that the set of letters of t is a subset of letters of s is as follows: aaa, aab, aac, aba, abb, abc, aca, acb, .... Among them, those are lexicographically greater than abc: aca, acb, .... Out of those the lexicographically smallest is aca.
/*
 * For the brave souls who get this far: You are the chosen ones,
 * the valiant knights of programming who toil away, without rest,
 * fixing our most awful code. To you, true saviors, kings of men,
 * I say this: never gonna give you up, never gonna let you down,
 * never gonna run around and desert you. Never gonna make you cry,
 * never gonna say goodbye. Never gonna tell a lie and hurt you.
 * 
 * And Logic is the strongest weapon. 
 *
 */

import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Map.Entry;

public class p4 {

    private static InputStream stream;
    private static byte[] buf = new byte[1024];
    private static int curChar;
    private static int numChars;
    private static SpaceCharFilter filter;
    private static PrintWriter pw;
    //private static int infi = (int) 1e9;
    //pw.print("Case #" + i + ": ");
    //private static final int N = 1234567;
    //private static final double MOD = 1e9 + 7;
    //Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));

    public static int soln() {
        int n = nI(), k = nI();
        char[] s = nS().toCharArray();
        int ai = 0;
        char[] ans = new char[k];
        int[] ii = new int[26];
        char min = 'z', max = 'a';
        for (int i = 0; i < n; i++) {
            ii[(int) s[i] - 'a']++;
            if (s[i] > max) {
                max = s[i];
            }
            if (s[i] < min) {
                min = s[i];
            }
        }
        for (int i = 0; i < Math.min(n, k); i++) {
            ans[i] = s[i];
        }
        if (k > n) {
            for (int i = n; i < k; i++) {
                ans[i] = min;
            }
        } else {
            for (int i = Math.min(n, k) - 1; i >= 0; i--) {
                if (s[i] >= max) {
                    ans[i] = min;
                } else {
                    int v = s[i] - 'a';
                    for (int j = v + 1; j < 26; j++) {
                        if (ii[j] > 0) {
                            ans[i] = (char) (j + 'a');
                            break;
                        }
                    }
                    break;
                }
            }
        }
        for (int i = 0; i < k; i++) {
            pw.print(ans[i]);
        }
        return 0;
    }

    public static void main(String[] args) throws FileNotFoundException {
        InputReader(System.in);
        //pw = new PrintWriter(new FileOutputStream("ans.txt"));
        //pw = new PrintWriter(new FileOutputStream("ans1.txt"));
        pw = new PrintWriter(System.out);
        soln();
        pw.close();
    }

    /*
     *********************************************************************************************
     */
    public static void InputReader(InputStream stream1) {
        stream = stream1;
    }

    private static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private static boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

    private static int read() {
        if (numChars == -1) {
            throw new InputMismatchException();
        }
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0) {
                return -1;
            }
        }
        return buf[curChar++];
    }

    private static void pIArr(int[] man) {
        int l = man.length;
        for (int i = 0; i < l; i++) {
            pw.print(man[i] + " ");
        }
        pw.println();
    }

    private static void pFArr(float[] man) {
        int l = man.length;
        for (int i = 0; i < l; i++) {
            pw.print(man[i] + " ");
        }
        pw.println();
    }

    private static void pCArr(char[] man) {
        int l = man.length;
        for (int i = 0; i < l; i++) {
            pw.print(man[i] + " ");
        }
        pw.println();
    }

    private static void pLArr(long[] man) {
        int l = man.length;
        for (int i = 0; i < l; i++) {
            pw.print(man[i] + " ");
        }
        pw.println();
    }

    private static int[] nIArr(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nI();
        }
        return a;
    }

    private static long[] nLArr(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = nL();
        }
        return a;
    }

    private static void pDArr(double[] man) {
        int l = man.length;
        for (int i = 0; i < l; i++) {
            pw.print(man[i] + " ");
        }
        pw.println();
    }

    private static double nD() {
        return Double.parseDouble(nS());
    }

    private static int nI() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    private static long nL() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    private static String nS() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    private static String nLi() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndOfLine(c));
        return res.toString();
    }

    private static boolean isSpaceChar(int c) {
        if (filter != null) {
            return filter.isSpaceChar(c);
        }
        return isWhitespace(c);
    }

    private interface SpaceCharFilter {

        public boolean isSpaceChar(int ch);
    }
}
