Problem: Vasya studies divisibility rules at school. Here are some of them:

  * Divisibility by 2. A number is divisible by 2 if and only if its last digit is divisible by 2 or in other words, is even.
  * Divisibility by 3. A number is divisible by 3 if and only if the sum of its digits is divisible by 3.
  * Divisibility by 4. A number is divisible by 4 if and only if its last two digits form a number that is divisible by 4.
  * Divisibility by 5. A number is divisible by 5 if and only if its last digit equals 5 or 0.
  * Divisibility by 6. A number is divisible by 6 if and only if it is divisible by 2 and 3 simultaneously (that is, if the last digit is even and the sum of all digits is divisible by 3).
  * Divisibility by 7. Vasya doesn't know such divisibility rule.
  * Divisibility by 8. A number is divisible by 8 if and only if its last three digits form a number that is divisible by 8.
  * Divisibility by 9. A number is divisible by 9 if and only if the sum of its digits is divisible by 9.
  * Divisibility by 10. A number is divisible by 10 if and only if its last digit is a zero.
  * Divisibility by 11. A number is divisible by 11 if and only if the sum of digits on its odd positions either equals to the sum of digits on the even positions, or they differ in a number that is divisible by 11.



Vasya got interested by the fact that some divisibility rules resemble each other. In fact, to check a number's divisibility by 2, 4, 5, 8 and 10 it is enough to check fulfiling some condition for one or several last digits. Vasya calls such rules the 2-type rules.

If checking divisibility means finding a sum of digits and checking whether the sum is divisible by the given number, then Vasya calls this rule the 3-type rule (because it works for numbers 3 and 9).

If we need to find the difference between the sum of digits on odd and even positions and check whether the difference is divisible by the given divisor, this rule is called the 11-type rule (it works for number 11).

In some cases we should divide the divisor into several factors and check whether rules of different types (2-type, 3-type or 11-type) work there. For example, for number 6 we check 2-type and 3-type rules, for number 66 we check all three types. Such mixed divisibility rules are called 6-type rules. 

And finally, there are some numbers for which no rule works: neither 2-type, nor 3-type, nor 11-type, nor 6-type. The least such number is number 7, so we'll say that in such cases the mysterious 7-type rule works, the one that Vasya hasn't discovered yet. 

Vasya's dream is finding divisibility rules for all possible numbers. He isn't going to stop on the decimal numbers only. As there are quite many numbers, ha can't do it all by himself. Vasya asked you to write a program that determines the divisibility rule type in the b-based notation for the given divisor d.

Input

The first input line contains two integers b and d (2 ≤ b, d ≤ 100) — the notation system base and the divisor. Both numbers are given in the decimal notation.

Output

On the first output line print the type of the rule in the b-based notation system, where the divisor is d: "2-type", "3-type", "11-type", "6-type" or "7-type". If there are several such types, print the one that goes earlier in the given sequence. If a number belongs to the 2-type, print on the second line the least number of the last b-based digits that we will need to use to check the divisibility.

Examples

Input

10 10


Output

2-type
1


Input

2 3


Output

11-type

Note

The divisibility rule for number 3 in binary notation looks as follows: "A number is divisible by 3 if and only if the sum of its digits that occupy the even places differs from the sum of digits that occupy the odd places, in a number that is divisible by 3". That's an 11-type rule. For example, 2110 = 101012. For it the sum of digits on odd positions equals 1 + 1 + 1 = 3, an on even positions — 0 + 0 = 0. The rule works and the number is divisible by 3. 

In some notations a number can fit into the 3-type rule and the 11-type rule. In this case the correct answer is "3-type".

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        final String[] types = new String[]{"2-type", "3-type", "11-type", "6-type", "7-type"};

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int base = in.nextInt(), number = in.nextInt();
            if (check2(base, number) != -1) {
                out.println(types[0]);
                out.println(check2(base, number));
                return;
            }

            if (base % number == 1) {
                out.println(types[1]);
                return;
            }

            if ((base + 1) % number == 0) {
                out.println(types[2]);
                return;
            }

            if (check6(base, number)) {
                out.println(types[3]);
                return;
            }

            out.println(types[4]);
        }

        private int check2(int n, int m) {
            List<Pairii> divs = new ArrayList<>();
            for (int i = 2; i <= m; ++i) {
                if (m % i == 0) {
                    int k = 0;
                    while (m % i == 0) {
                        m /= i;
                        k++;
                    }
                    divs.add(new Pairii(i, k));
                }
            }

            int ans = 0;
            for (Pairii p : divs) {
                if (n % p.first != 0)
                    return -1;

                int cnt = 0;
                while (n % p.first == 0) {
                    cnt++;
                    n /= p.first;
                }

                ans = Math.max(ans, (p.second + cnt - 1) / cnt);
            }

            return ans;
        }

        private boolean check2_3_11(int base, int number) {
            if (number == 1) return false;
            if (check2(base, number) != -1) {
                return true;
            }

            if (base % number == 1) {
                return true;
            }

            if ((base + 1) % number == 0) {
                return true;
            }
            return false;
        }

        private boolean check6(int n, int m) {
            List<Integer> divs = new ArrayList<>();

            for (int i = 2; i <= m; ++i) {
                int p = 1;
                while (m % i == 0) {
                    m /= i;
                    p *= i;
                }
                if (p > 1) divs.add(p);
            }

            for (int p : divs)
                if (!check2_3_11(n, p))
                    return false;

            return true;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

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

        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }

    static class Pairii implements Comparable<Pairii> {
        public int first;
        public int second;

        public Pairii() {
        }

        public Pairii(int first, int second) {
            this.first = first;
            this.second = second;
        }

        public int compareTo(Pairii other) {
            if (first != other.first) return first < other.first ? -1 : 1;
            if (second != other.second) return second < other.second ? -1 : 1;
            return 0;
        }

        public boolean equals(Object other) {
            if (!(other instanceof Pairii)) return false;
            return compareTo((Pairii) other) == 0;
        }

        public int hashCode() {
            return first * 31 + second;
        }

    }
}