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.*;
import java.math.BigInteger;
import java.util.*;

/**
 * Created by ribra on 11/15/2015.
 */
public class Main {

    private static InputReader sc = new InputReader(System.in);
    private static PrintWriter out = new PrintWriter(System.out);



    public static void main(String [] args) throws Exception {

        int n = sc.nextInt();
        int p = sc.nextInt();
        int q = sc.nextInt();

        String str = sc.next();

        int l = str.length();


        if (l % p == 0) {
            int k = l / p;
            out.println(k);
            for (int i = 0; i < k; i++) {
                out.println(str.substring(i * p, i * p + p));
            }
        }
        else if (l % q == 0) {
            int k = l / q;
            out.println(k);
            for (int i = 0; i < k; i++) {
                out.println(str.substring(i * q, i * q + q));
            }
        }
        else {
            if (p + q > n) out.print("-1");
            else {
                int z, x;
                z = x = 0;
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        if (i * p + j * q == n) {
                            z = i;
                            x = j;
                        }
                    }
                }

                if (z == 0 && x == 0) out.print("-1");
                else {
                    out.println(z + x);
                    int i;
                    for (i = 0; i < z; i++) {
                        out.println(str.substring(i * p, i * p + p));
                    }

                    for (int j = 0; j < x; j++) {
                        out.println(str.substring(i * p + j * q, i * p + j * q + q));
                    }
                }
            }
        }





        terminate();
    }

    




    public static void terminate() {
        out.close();
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }

    static class Graph {
        private int V;
        private int E;
        private Set<Integer>[] adj;

        public Graph(int V) {
            this.V = V;
            this.E = 0;
            adj = new HashSet[V];
            for (int i = 0; i < V; i++)
                adj[i] = new HashSet<>();
        }


        public int V() {
            return V;
        }

        public int E() {
            return E;
        }

        public void addEdge(int v, int w) {
            adj[v].add(w);
            adj[w].add(v);
            E++;
        }

        public Iterable<Integer> adj(int v) {
            return adj[v];
        }


        public static int degree(Graph g, int v) {
            int degree = 0;
            for (int w : g.adj(v)) degree++;
            return degree;
        }


        public static int maxDegree(Graph g) {
            int max = 0;
            for (int i = 0; i < g.V(); i++)
                max = Math.max(degree(g, i), max);
            return max;
        }


        public static int avgDegree(Graph g) {
            int sum = 0;
            for (int i = 0; i < g.V(); i++)
                sum += degree(g, i);
            return sum / g.V();
        }


        public static int avgDegreeEfficient(Graph g) {
            // g.E = sum degree of every graph
            // 2 * g.E - because if v is connected to w, then w is connected to v as well
            // and divide by number of vertices
            return 2 * g.E() / g.V();
        }

        public static int numberOfSelfLoops(Graph g) {
            int count = 0;
            for (int i = 0; i < g.V(); i++)
                for (int w : g.adj(i))
                    if (i == w) count++;
            return count / 2;
        }

        public String toString()
        {
            String s = V() + " vertices, " + E() + " edges\n";
            for (int v = 0; v < V(); v++)
            {
                s += v + ": ";
                for (int w : this.adj(v))
                    s += w + " ";
                s += "\n";
            }
            return s;
        }

    }
}

