Anfisa the monkey learns to type. She is yet unfamiliar with the "space" key and can only type in lower-case Latin letters. Having typed for a fairly long line, Anfisa understood that it would be great to divide what she has written into k lines not shorter than a and not longer than b, for the text to resemble human speech more. Help Anfisa.

Input

The first line contains three integers k, a and b (1 ≤ k ≤ 200, 1 ≤ a ≤ b ≤ 200). The second line contains a sequence of lowercase Latin letters — the text typed by Anfisa. It is guaranteed that the given line is not empty and its length does not exceed 200 symbols.

Output

Print k lines, each of which contains no less than a and no more than b symbols — Anfisa's text divided into lines. It is not allowed to perform any changes in the text, such as: deleting or adding symbols, changing their order, etc. If the solution is not unique, print any of them. If there is no solution, print "No solution" (without quotes). 

Examples

Input

3 2 5
abrakadabra


Output

ab
rakad
abra


Input

4 1 2
abrakadabra


Output

No solution
    import java.util.*;
    import java.lang.*;
    import java.io.Writer;
    import java.io.BufferedWriter;
    import java.io.OutputStreamWriter;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.math.BigInteger;
    import java.util.Arrays;
    import java.util.ArrayList;
    import java.util.InputMismatchException;

    public class Main {

        static class ProblemSolver{
            public void solveTheProblem(InputReader in,OutputWriter out,NumberTheory numb) {
                 int k=in.nextInt(),a=in.nextInt(),b=in.nextInt();
                 String s=in.nextString();
                 if(s.length()<(k*a)||s.length()>(k*b)){
                     out.println("No solution");
                 }
                 else{
                     int wordsperline=s.length()/k;
                     int extraletters=s.length()%k;
                     int m=k,extra=1,j=0;
                     while(m>0){
                         if(extraletters>0){
                             extra=1;
                         }
                         else{
                             extra=0;
                         }
                         for(int i=0;i<wordsperline+extra;i++){
                             out.print(s.charAt(j));
                             j++;
                         }
                         out.println();
                         extraletters--;
                         m--;
                     }
                 }
            }
        }
        public static void main(String args[]) {
            InputStream inputStream=System.in;
            OutputStream outputStream=System.out;
            InputReader in=new InputReader(inputStream);
            OutputWriter out=new OutputWriter(outputStream);
            NumberTheory numb = new NumberTheory();
            ProblemSolver problemSolver=new ProblemSolver();
            problemSolver.solveTheProblem(in,out,numb);
            out.flush();
            out.close();
        }

        static class InputReader {
            private boolean finished = false;

            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;

            public InputReader(InputStream stream) {
                this.stream = stream;
            }

            public 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++];
            }

            public int peek() {
                if (numChars == -1) {
                    return -1;
                }
                if (curChar >= numChars) {
                    curChar = 0;
                    try {
                        numChars = stream.read(buf);
                    } catch (IOException e) {
                        return -1;
                    }
                    if (numChars <= 0) {
                        return -1;
                    }
                }
                return buf[curChar];
            }

            public int nextInt() {
                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;
            }

            public long nextLong() {
                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;
            }

            public String nextString() {
                int c = read();
                while (isSpaceChar(c)) {
                    c = read();
                }
                StringBuilder res = new StringBuilder();
                do {
                    if (Character.isValidCodePoint(c)) {
                        res.appendCodePoint(c);
                    }
                    c = read();
                } while (!isSpaceChar(c));
                return res.toString();
            }

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

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

            private String readLine0() {
                StringBuilder buf = new StringBuilder();
                int c = read();
                while (c != '\n' && c != -1) {
                    if (c != '\r') {
                        buf.appendCodePoint(c);
                    }
                    c = read();
                }
                return buf.toString();
            }

            public String readLine() {
                String s = readLine0();
                while (s.trim().length() == 0) {
                    s = readLine0();
                }
                return s;
            }

            public String readLine(boolean ignoreEmptyLines) {
                if (ignoreEmptyLines) {
                    return readLine();
                } else {
                    return readLine0();
                }
            }

            public BigInteger readBigInteger() {
                try {
                    return new BigInteger(nextString());
                } catch (NumberFormatException e) {
                    throw new InputMismatchException();
                }
            }

            public char nextCharacter() {
                int c = read();
                while (isSpaceChar(c)) {
                    c = read();
                }
                return (char) c;
            }

            public double nextDouble() {
                int c = read();
                while (isSpaceChar(c)) {
                    c = read();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c)) {
                        if (c == 'e' || c == 'E') {
                            return res * Math.pow(10, nextInt());
                        }
                        if (c < '0' || c > '9') {
                            throw new InputMismatchException();
                        }
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }

            public boolean isExhausted() {
                int value;
                while (isSpaceChar(value = peek()) && value != -1) {
                    read();
                }
                return value == -1;
            }

            public String next() {
                return nextString();
            }

            public SpaceCharFilter getFilter() {
                return filter;
            }

            public void setFilter(SpaceCharFilter filter) {
                this.filter = filter;
            }

            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
            public int[] nextIntArray(int n){
                int[] array=new int[n];
                for(int i=0;i<n;++i)array[i]=nextInt();
                return array;
            }
            public int[] nextSortedIntArray(int n){
                int array[]=nextIntArray(n);
                Arrays.sort(array);
                return array;
            }
            public int[] nextSumIntArray(int n){
                int[] array=new int[n];
                array[0]=nextInt();
                for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
                return array;
            }
            public long[] nextLongArray(int n){
                long[] array=new long[n];
                for(int i=0;i<n;++i)array[i]=nextLong();
                return array;
            }
            public long[] nextSumLongArray(int n){
                long[] array=new long[n];
                array[0]=nextInt();
                for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
                return array;
            }
            public long[] nextSortedLongArray(int n){
                long array[]=nextLongArray(n);
                Arrays.sort(array);
                return array;
            }
            public int[][] nextIntMatrix(int n,int m){
                int[][] matrix=new int[n][m];
                for(int i=0;i<n;++i)
                    for(int j=0;j<m;++j)
                        matrix[i][j]=nextInt();
                return matrix;
            }

            public int[][] nextIntMatrix(int n){
                return nextIntMatrix(n,n);
            }

            public long[][] nextLongMatrix(int n,int m){
                long[][] matrix=new long[n][m];
                for(int i=0;i<n;++i)
                    for(int j=0;j<m;++j)
                        matrix[i][j]=nextLong();
                return matrix;
            }

            public long[][] nextLongMatrix(int n){
                return nextLongMatrix(n,n);
            }

            public char[][] nextCharMatrix(int n,int m){
                char[][] matrix=new char[n][m];
                for(int i=0;i<n;++i)
                    matrix[i]=next().toCharArray();
                return matrix;
            }

            public char[][] nextCharMatrix(int n){
                return nextCharMatrix(n,n);
            }
        }

        static class OutputWriter {
            private final PrintWriter writer;

            public OutputWriter(OutputStream outputStream) {
                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
            }

            public OutputWriter(Writer writer) {
                this.writer = new PrintWriter(writer);
            }



            public void print(Object... objects) {
                for (int i = 0; i < objects.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(objects[i]);
                }
            }

            public void print(int[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(double[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(long[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(char[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(String[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(int[][] matrix){
                for(int i=0;i<matrix.length;++i){
                    println(matrix[i]);
                }
            }

            public void print(double[][] matrix){
                for(int i=0;i<matrix.length;++i){
                    println(matrix[i]);
                }
            }

            public void print(long[][] matrix){
                for(int i=0;i<matrix.length;++i){
                    println(matrix[i]);
                }
            }

            public void print(char[][] matrix){
                for(int i=0;i<matrix.length;++i){
                    println(matrix[i]);
                }
            }

            public void print(String[][] matrix){
                for(int i=0;i<matrix.length;++i){
                    println(matrix[i]);
                }
            }

            public void println(int[] array) {
                print(array);
                writer.println();
            }

            public void println(double[] array) {
                print(array);
                writer.println();
            }

            public void println(long[] array) {
                print(array);
                writer.println();
            }

            public void println(char[] array) {
                print(array);
                writer.println();
            }

            public void println(String[] array) {
                print(array);
                writer.println();
            }

            public void println() {
                writer.println();
            }

            public void println(Object... objects) {
                print(objects);
                writer.println();
            }

            public void print(char i) {
                writer.print(i);
            }

            public void println(char i) {
                writer.println(i);
            }



            public void printf(String format, Object... objects) {
                writer.printf(format, objects);
            }

            public void close() {
                writer.close();
            }

            public void flush() {
                writer.flush();
            }

            public void print(long i) {
                writer.print(i);
            }

            public void println(long i) {
                writer.println(i);
            }

            public void print(int i) {
                writer.print(i);
            }

            public void println(int i) {
                writer.println(i);
            }

            public void separateLines(int[] array) {
                for (int i : array) {
                    println(i);
                }
            }

        }

        static class NumberTheory{

            /**
             * Modular Arithmetic:
             *  1. (a+b)%c=(a%c+b%c)%c
             *  2. (a*b)%c=(a%c*b%c)%c
             *  3. (a-b)%c=(a%c-b%c+c)%c
             *  4. (a/b)%c=(a%c*(b^-1)%c)%c -- (b^-1 is multiplicative modulo inverse)
             */
            //Modular Addition
            public int modularAddition(int a,int b,int MOD){
                return (a%MOD+b%MOD)%MOD;
            }
            public long modularAddition(long a,long b,long MOD){
                return (a%MOD+b%MOD)%MOD;
            }
            //Modular Multiplication
            public int modularMultiplication(int a,int b,int MOD){
                return ((a%MOD)*(b%MOD))%MOD;
            }
            public long modularMultiplication(long a,long b,long MOD){
                return ((a%MOD)*(b%MOD))%MOD;
            }
            //Modular Subtraction
            public int modularSubtraction(int a,int b,int MOD){
                return (a%MOD-b%MOD+MOD)%MOD;
            }
            public long modularSubtraction(long a,long b,long MOD){
                return (a%MOD-b%MOD+MOD)%MOD;
            }

            /**
             * Binary Exponentiation
             */
            public int binaryExponentiation(int x,int n){
                if(n==0)return 1;
                else if(n%2==0)return binaryExponentiation(x*x,n/2);
                else return x*binaryExponentiation(x*x,(n-1)/2);
            }
            public long binaryExponentiation(long x,long n){
                long result=1;
                while(n>0){
                    if(n%2==1)result*=x;
                    x=x*x;
                    n/=2;
                }
                return result;
            }

            /**
             * Modular Exponentiation
             */
            public int modularExponentiation(int x,int n,int MOD){
                if(n==0)return 1%MOD;
                else if(n%2==0)return modularExponentiation(modularMultiplication(x,x,MOD),n/2,MOD);
                else return modularMultiplication(x,modularExponentiation(modularMultiplication(x,x,MOD),(n-1)/2,MOD),MOD);
            }
            public long modularExponentiation(long x,long n,long MOD){
                long result=1;
                while(n>0){
                    if(n%2==1)result=modularMultiplication(result,x,MOD);
                    x=modularMultiplication(x,x,MOD);
                    n/=2;
                }
                return result;
            }

            /**
             * Factorial of a number
             */
            public long factorials(long n){
                if(n==0)return 1;
                return n*factorials(n-1);
            }

            /**
             * Prime factors of a number
             */
            public ArrayList<Integer> distinctPrimeFactors(int n){
                ArrayList<Integer> factorials=new ArrayList<>();
                int limit=(int)Math.sqrt(n);
                if(n%2==0){
                    factorials.add(2);
                    while(n%2==0)n/=2;
                }
                for(int i=3;i<=limit;i+=2){
                    if(n%i==0){
                        factorials.add(i);
                        while(n%i==0)n/=i;
                    }
                }
                if(n>2)factorials.add(n);
                return factorials;
            }

            public ArrayList<Long> distinctPrimeFactors(long n){
                ArrayList<Long> factorials=new ArrayList<>();
                long limit=(long)Math.sqrt(n);
                if(n%2==0){
                    factorials.add((long)2);
                    while(n%2==0)n/=2;
                }
                for(long i=3;i<=limit;i+=2){
                    if(n%i==0){
                        factorials.add(i);
                        while(n%i==0)n/=i;
                    }
                }
                if(n>2)factorials.add(n);
                return factorials;
            }

            public ArrayList<Integer> primeFactors(int n){
                ArrayList<Integer> factorials=new ArrayList<>();
                int limit=(int)Math.sqrt(n);
                if(n%2==0){
                    factorials.add(2);
                    while(n%2==0)n/=2;
                }
                for(int i=3;i<=limit;i+=2){
                    if(n%i==0){
                        factorials.add(i);
                        while(n%i==0)n/=i;
                    }
                }
                if(n>2)factorials.add(n);
                return factorials;
            }

            public ArrayList<Long> primeFactors(long n){
                ArrayList<Long> factorials=new ArrayList<>();
                long limit=(long)Math.sqrt(n);
                if(n%2==0){
                    factorials.add((long)2);
                    while(n%2==0)n/=2;
                }
                for(long i=3;i<=limit;i+=2){
                    if(n%i==0){
                        factorials.add(i);
                        while(n%i==0)n/=i;
                    }
                }
                if(n>2)factorials.add(n);
                return factorials;
            }

            /**
             * Combination: nCr
             */
            //Naive version
            //(n,r)=(n-1,r-1)+(n-1,r) for r!=0 or r!=n
            //(n,0)=(n,n)=1
            public int binomialCoefficientRecursive(int n,int k){
                if(k==0 || k==n)return 1;//base case
                return binomialCoefficientRecursive(n-1,k-1)+binomialCoefficientRecursive(n-1,k);//recursion
            }

            //Dynamic Programming version(Uses bottom up approach to fill the table)
            //Time complexity: O(n*k)
            //Space complexity: O(n*k)
            public long binomialCoefficientIterative(int n,int k){
                long[][] C=new long[n+1][k+1];
                for(int i=0;i<=n;++i){
                    for(int j=0;j<=Math.min(n,k);++j){
                        if(j==0 || j==i)C[i][j]=1;
                        else C[i][j]=C[i-1][j-1]+C[i-1][j];
                    }
                }
                return C[n][k];
            }

            //Pascal's Triangle version(Space efficient program)
            //Time complexity: O(n*k)
            //Space complexity: O(k)
            public long nCr(int n,int r){
                int[] C=new int[r+1];
                C[0]=1;//nC0=1
                for(int i=1;i<=n;++i)
                    for(int j=Math.min(i,r);j>0;--j)
                        C[j]=C[j]+C[j-1];
                return C[r];
            }

            /**
             * Catlan number:
             *  - Time complexity: O(n*n)
             *  - Auxiliary space: O(n)
             *
             *  NOTE: Time complexity could be reduced to O(n) but it is
             *        possible if and only if n is small or else there is
             *        a chance of getting an overflow. To decrease the time
             *        complexity to O(n) just remember nCr=nCn-r
             */
            public long catlanNumber(int n){
                long[] catlan=new long[n+1];
                catlan[0]=catlan[1]=1;
                for(int i=2;i<=n;++i)
                    for(int j=0;j<i;++j)
                        catlan[i]+=catlan[j]*catlan[i-1-j];

                return catlan[n];
            }

            /**
             * Greatest Common Divisor(GCD)
             *  - It is also known as Highest Common Factor(HCF)
             *  - Time complexity: log(min(a,b))
             *  - Auxiliary Space: O(1)
             */
            public int gcd(int a,int b){
                if(b==0)return a;
                return gcd(b%a,a);
            }

            public long gcd(long a,long b){
                if(b==0)return a;
                return gcd(b%a,a);
            }





            /**
             * Least Common Multiple(LCM):
             *  - Time complexity: log(min(a,b))
             *  - Auxiliary Space: O(1)
             */
            public long lcm(long a,long b){
                return (a*b)/gcd(a,b);
            }

        }
    }