You are given the string s of length n and the numbers p, q. Split the string s to pieces of length p and q.

For example, the string "Hello" for p = 2, q = 3 can be split to the two strings "Hel" and "lo" or to the two strings "He" and "llo".

Note it is allowed to split the string s to the strings only of length p or to the strings only of length q (see the second sample test).

Input

The first line contains three positive integers n, p, q (1 ≤ p, q ≤ n ≤ 100).

The second line contains the string s consists of lowercase and uppercase latin letters and digits.

Output

If it's impossible to split the string s to the strings of length p and q print the only number "-1".

Otherwise in the first line print integer k — the number of strings in partition of s.

Each of the next k lines should contain the strings in partition. Each string should be of the length p or q. The string should be in order of their appearing in string s — from left to right.

If there are several solutions print any of them.

Examples

Input

5 2 3
Hello


Output

2
He
llo


Input

10 9 5
Codeforces


Output

2
Codef
orces


Input

6 4 5
Privet


Output

-1


Input

8 1 1
abacabac


Output

8
a
b
a
c
a
b
a
c
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Tests {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		int np = 0;
		int nq = 0;
		int total = np + nq;
		int index = 0;
		
		Reader.init(System.in);
		Writer.init(System.out);
		int n = Reader.nextInt();
		int p = Reader.nextInt();
		int q = Reader.nextInt();
		
		String word = Reader.next();
		
		// p = Math.min(p, q);
		// q = Math.max(p, q);
		// Special faulty case....
		if ((n < p && n < q) || (n % 2 != 0 && p % 2 == 0 && q % 2 == 0)  || !CanSub(n, p, q)||  !Subset(n, p, q, 0)){
			Writer.os.write((-1 + "\n").getBytes());
			Writer.os.flush();
		}
		else {

			if ((n % p) % (q) == 0) {
				np = n / p;
				nq = (n % p) / q;
				total = np + nq;
				Writer.os.write((total + "\n").getBytes());
				Writer.os.flush();				
				index = printSubs(word, 0, np, p);
				index = printSubs(word, index, nq, q);
			} else if ((n % q) % (p) == 0) {
				nq = n / q;
				np = (n % q) / p;
				total = nq + np;
				Writer.os.write((total + "\n").getBytes());
				Writer.os.flush();	
				index = printSubs(word, 0, nq, q);
				index = printSubs(word, index, np, p);
			} else {
				int[] arr = findSubset(n, p, q);
				np = arr[0];
				nq = arr[1];
				total = np + nq;
				Writer.os.write((total + "\n").getBytes());
				Writer.os.flush();	
				index = printSubs(word, 0, np, p);
				index = printSubs(word, index, nq, q);

			}

		}

	}

	private static int printSubs(String word, int start, int times, int step) throws IOException {

		int index = 0;

		for (int i = 0; i < times; ++i) {
			Writer.os.write((word.substring(start,start+step) + "\n").getBytes());
			Writer.os.flush();	
			if (i != times - 1)
				start = start + step;
		}

		index = start + step;
		return index;
	}

	private static int[] findSubset(int n, int p, int q) {

		int sum;
		int[] fact = new int[2];
		myloop: for (int i = 1;; ++i) {
			for (int j = 0;; ++j) {
				sum = (i * p) + (j * q);
				if (sum == n) {
					fact[0] = i;
					fact[1] = j;
					return fact;
				} else if (sum > n)
					continue myloop;

			}
		}
	}

	@SuppressWarnings("unused")
	private static boolean Subset(int n, int p, int q, int sum) {
	
		if (sum > n)
			return false;
		if (sum == n)
			return true;
		
		return Subset(n, p, q, sum + p) || Subset(n, p, q, sum + q);

	}
	
	private static boolean CanSub(int n , int p , int q){
		
		int sum;
		myloop : for(int i = 0 ; i<=n; i++){
			for(int j = 0; j<=n; ++ j){
				sum = i*p + j*q;
				if(sum > n)
					continue myloop;
				if(sum == n)
					return true;
			}
		}
		return false;
	}


/** Class for buffered reading int and double values */
static class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

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

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}

static class Writer{
	static OutputStream os;
	
	static void init(OutputStream out){
		os = new BufferedOutputStream(out);
	}
}
}
