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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
		
			 
			public class Solution1 implements Runnable
			{
				static final int MAX = 1000000007;
				static class InputReader
				{
					private InputStream stream;
					private byte[] buf = new byte[1024];
					private int curChar;
					private int numChars;
					private SpaceCharFilter filter;
					private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			
					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 String nextLine()
					{
						String str = "";
			            try
			            {
			                str = br.readLine();
			            }
			            catch (IOException e)
			            {
			                e.printStackTrace();
			            }
			            return str;
					}
					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 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 String readString() 
					{
						int c = read();
						while (isSpaceChar(c))
							c = read();
						StringBuilder res = new StringBuilder();
						do 
						{
							res.appendCodePoint(c);
							c = read();
						} 
						while (!isSpaceChar(c));
						
						return res.toString();
					}
				 
					public boolean isSpaceChar(int c) 
					{
						if (filter != null)
							return filter.isSpaceChar(c);
						return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
					}
				 
					public String next() 
					{
						return readString();
					}
					
					public interface SpaceCharFilter 
					{
						public boolean isSpaceChar(int ch);
					}
				}
			 	
				public static void main(String args[]) throws Exception
				{
					new Thread(null, new Solution1(),"Solution1",1<<26).start();
				}	
				public void run()
				{
					InputReader sc= new InputReader(System.in);
					PrintWriter w= new PrintWriter(System.out);
					int n = sc.nextInt();
					int p = sc.nextInt();
					int q = sc.nextInt();
					String s = sc.next();
					boolean flag = false;
					if(n % p == 0){
						w.println(n/p);
						for(int i = 0;i < s.length();i+=p){
							w.println(s.substring(i,i+p));
						}
						flag = true;
					}else if(n % q == 0){
						w.println(n/q);
						for(int i = 0;i < s.length();i+=(q)){
							w.println(s.substring(i,i+q));
						}
						flag = true;
					}else{
		outer:				for(int i = 1;i <= 100;i++){
							for(int j = 1;j <= 100;j++){
								if(fun(i,j,n,p,q)){
									flag= true;
									w.println(i+j);
									int count = 0;
									for(int k = 0;k < s.length();){
										count++;
										if(count <= i){
											w.println(s.substring(k,k+p));
											k+=p;
										}else{
											w.println(s.substring(k,k+q));
											k+=q;
										}
									}
									break outer;
								}
							}
						}
						
					}
					if(!flag){
						w.println("-1");
					}
					w.close();
				}
				static boolean fun(int a,int b,int n,int p,int q){
					if(a*p + b*q == n){
						return true;
					}
					return false;
				}
				static class Pair implements Comparable<Pair>{
					long a;
					int b;
					Pair(long a,int b){
						this.a = a;
						this.b = b;
					}
					public boolean equals(Object o)
					{
						Pair p = (Pair)o;
						return p.a==a && p.b==b;
					}
					public int compareTo(Pair p){
						return Long.compare(this.a,p.a);
					}
					public int hashCode()
					{
						return new Long(a).hashCode()*31 + new Long(a).hashCode();
					}
				}
			}  