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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class test6 {

	public static final int mod=1000000007;
	
	static LinkedList<Integer> idx=new LinkedList<>();
	static int a,b,n;
	static String s;
	static int dp[][];
	public static void main(String[] args) throws IOException {
		
		BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
		//Scanner sc=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);
		
		String[] ipp=sc.readLine().split(" ");
		int k=Integer.parseInt(ipp[0]);
		a=Integer.parseInt(ipp[1]);
		b=Integer.parseInt(ipp[2]);
		s=sc.readLine();
		n=s.length();
		dp=new int[n][k];
		for(int[] r:dp) Arrays.fill(r, -1);
		int prev=0;
		if(solve(0,k-1)) {			
			for(int e:idx) {
				out.println(s.substring(prev,e));
				prev=e;
			}
			out.print(s.substring(idx.peekLast()));
		} else {
			out.print("No solution");
		}
		
		out.flush();
		out.close();
	}
	
	static boolean solve(int id,int k) {
		if(dp[id][k]>-1) return dp[id][k]==0?false:true;
		String temp=s.substring(id);
		if(k==0) {
			if(temp.length()>=a && temp.length()<=b) { dp[id][k]=1;return true;}
			else {dp[id][k]=0;return false;}
		}
		if(temp.length()<a) {dp[id][k]=0;return false;}
		for(int i=id+a;i<=Math.min(id+b, s.length()-1);i++) {
			idx.add(i);
			boolean poss=solve(i,k-1);
			if(!poss) {
				idx.removeLast();				
			} else {
				dp[id][k]=1;
				return true;
			}
		}
		dp[id][k]=0;
		return false;
	}
	
	static boolean[] sieveOfEratosthenes(int n) 
    {         
        boolean prime[] = new boolean[n+1]; 
        for(int i=0;i<n;i++) 
            prime[i] = true; 
          
        for(int p = 2; p*p <=n; p++) 
        { 
            if(prime[p] == true) 
            { 
                for(int i = p*2; i <= n; i += p) 
                    prime[i] = false; 
            } 
        }           
       return prime;
    } 
	
	boolean isPrime(long n) {
	    if(n < 2) return false;
	    if(n == 2 || n == 3) return true;
	    if(n%2 == 0 || n%3 == 0) return false;
	    long sqrtN = (long)Math.sqrt(n)+1;
	    for(long i = 6L; i <= sqrtN; i += 6) {
	        if(n%(i-1) == 0 || n%(i+1) == 0) return false;
	    }
	    return true;
	}
	
	public static int binarySearch(int arr[], int l, int r, int x) 
	{ 
	    while (l <= r) { 
	        int m = l + (r - l) / 2; 
	  
	        // Check if x is present at mid 
	        if (arr[m] == x) 
	            return m; 
	  
	        // If x greater, ignore left half 
	        if (arr[m] < x) 
	            l = m + 1; 
	  
	        // If x is smaller, ignore right half 
	        else
	            r = m - 1; 
	    } 
	  
	    // if we reach here, then element was 
	    // not present 
	    return -1; 
	} 
		
	public static int first(int arr[], int low, int high, int x) 
    { 
        if (high >= low) { 
            int mid = low + (high - low) / 2; 
            if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x) 
                return mid; 
            else if (x > arr[mid]) 
                return first(arr, (mid + 1), high, x); 
            else
                return first(arr, low, (mid - 1), x); 
        } 
        return -1; 
    }
	
	public static int last(int arr[], int low, int high, int x, int n) 
    { 
        if (high >= low) { 
            int mid = low + (high - low) / 2; 
            if ((mid == n - 1 || x < arr[mid + 1]) && arr[mid] == x) 
                return mid; 
            else if (x < arr[mid]) 
                return last(arr, low, (mid - 1), x, n); 
            else
                return last(arr, (mid + 1), high, x, n); 
        } 
        return -1; 
    } 
	
	public static int gcd(int A, int B) {
	    if(B==0)
	        return A;
	    else
	        return gcd(B, A % B);
	}
	
	public static class Pair{
		int l=0;
		int r=0;
		Pair(int a,int b){
			l=a;
			r=b;
		}		
	}
	
}

