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.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    public static void main(String[] args) throws IOException {
       // BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        //(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
        PrintWriter p=new PrintWriter(System.out);
        StringTokenizer tk;
        Reader.init(System.in);
        int k=Reader.nextInt(),a=Reader.nextInt(),b=Reader.nextInt();
        char[]c=Reader.next().toCharArray();
        if(c.length/k<a||(double)c.length/(double)k>(double)b){
            System.out.println("No solution");
            return;
        }
      int dp[]=new int[k];
      Arrays.fill(dp, a);
      int con=c.length-a*k;
      int ind=0;
        while(con>0){
            if(con-abs(a-b)<0){
            dp[ind]+=con;
            break;
            }
        dp[ind]+=abs(a-b);
        con-=abs(a-b);
        ind++;
        }
        String []ans=new String[k];
        int m=0;
        for (int i = 0; i < ans.length; i++) {
            ans[i]="";
            for (int j = 0; j < dp[i]; j++) {
            
                if(m>=c.length)
                    break;
                ans[i]+=c[m++];
            }
            out.append(ans[i]).append("\n");
        }
        System.out.print(out);
    }
}

class Reader {

    static StringTokenizer tokenizer;
    static BufferedReader reader;

    public static void init(InputStream input) throws UnsupportedEncodingException {
        reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
        tokenizer = new StringTokenizer("");
    }

    public static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    public static String nextLine() throws IOException {
        return reader.readLine();
    }

    public static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
}