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

import static java.lang.Math.*;

public class Main implements Runnable {
    
    static String filename = "";
    
    int[] factorize(int n) {
        ArrayList<Integer> ans = new ArrayList<Integer>();
        for (int i = 2; i <= n; i++) {
            while (n % i == 0) {
                ans.add(i);
                n /= i;
            }
        }
        int[] ansa = new int[ans.size()];
        for (int i = 0; i < ans.size(); i++) {
            ansa[i] = ans.get(i);
        }
        return ansa;
    }
    
    int gcd(int a, int b) {
        while (b != 0) {
            a %= b;
            int temp = a;
            a = b;
            b = temp;
        }
        return a;
    }
    
    int digitsum(int n, int b) {
        int ans = 0;
        while (n > 0) {
            ans += n % b;
            n /= b;
        }
        return ans;
    }
    
    int get3(int b) {
        Random rnd = new Random();
        int ans = 0;
        for (int i = 0; i < 10000; i++) {
            int num = rnd.nextInt(1000000000);
            ans = gcd(ans, num - digitsum(num, b));
        }
        return ans;
    }
    
    int is2type(int b, int d) {
        int[] bfactors = factorize(b);
        int[] dfactors = factorize(d);
            
        boolean type2 = true;
        TreeMap<Integer, Integer> bf = new TreeMap<Integer, Integer>();
        for (int i : bfactors) {
            if (!bf.containsKey(i)) {
                bf.put(i, 0);
            }
            bf.put(i, bf.get(i) + 1);
        }
        TreeMap<Integer, Integer> df = new TreeMap<Integer, Integer>();
        for (int i : dfactors) {
            if (!df.containsKey(i)) {
                df.put(i, 0);
            }
            df.put(i, df.get(i) + 1);
        }
        for (int i : dfactors) {
            if (!bf.containsKey(i)) {
                type2 = false;
            }
        }
        
        if (type2) {
            int ans = 0;
            long pow = 1;
            while (pow % d != 0) {
                pow *= b;
                ans++;
                /*
                for (Map.Entry<Integer, Integer> e : df.entrySet()) {
                    System.out.println(e.getKey() + " " + e.getValue());
                }
                System.out.println();
                */
            }
            return ans;
        } else {
            return -1;
        }
    }
    
    boolean is3type(int b, int d) {
        return (b - 1) % d == 0;
    }
    
    boolean is11type(int b, int d) {
        return (b + 1) % d == 0;
    }
    
    HashMap<Integer, Boolean> type6 = new HashMap<Integer, Boolean>();
    
    boolean is6type(int b, int d) {
        if (type6.containsKey(d)) {
            return type6.get(d);
        }
        for (int i = 2; i < d; i++) {
            if (d % i == 0) {
                int di = d / i;
                if (i % di == 0 || di % i == 0) {
                    continue;
                }
                boolean[] m1 = getMask(b, i);
                boolean[] m2 = getMask(b, di);
                for (int ii = 0; ii < 4; ii++) {
                    for (int jj = 0; jj < 4; jj++) {
                        if (ii == jj) {
                            continue;
                        }
                        if (m1[ii] && m2[jj]) {
                            type6.put(d, true);
                            return true;
                        }
                    }
                }
                /*
                if (is2type(b, i) != -1 || is3type(b, i) || is11type(b, i) || is6type(b, i)) {
                    if (is2type(b, di) != -1 || is3type(b, di) || is11type(b, di) || is6type(b, di)) {
                        if (is3type(b, i) && is3type(b, di))
                            continue;
                        type6.put(d, true);
                        return true;
                    }
                }
                */
            }
        }
        type6.put(d, false);
        return false;
    }
    
    boolean[] getMask(int b, int d) {
        boolean[] ans = new boolean[4];
        ans[0] = is2type(b, d) != -1;
        ans[1] = is3type(b, d);
        ans[2] = is11type(b, d);
        ans[3] = is6type(b, d);
        return ans;
    }
    
    public void solve() throws Exception {
        int b = sc.nextInt(), d = sc.nextInt();
        int ans;
        if ((ans = is2type(b, d)) != -1) {
            out.println("2-type");
            out.println(ans);
        } else if (is3type(b, d)) {
            out.println("3-type");
        } else if (is11type(b, d)) {
            out.println("11-type");
        } else if (is6type(b, d)) {
            out.println("6-type");
        } else {
            out.println("7-type");
        }
    }
    
    BufferedReader in;
    PrintWriter out;
    FastScanner sc;
    
    public static void main(String[] args) {
        new Thread(null, new Main(), "", 1 << 25).start();
    }
    
    @Override
    public void run() {
        try {
            init();
            solve();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            out.close();
        }
    }
    
    void init() throws Exception {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        sc = new FastScanner(in);
    }
}

class FastScanner {
    
    BufferedReader reader;
    StringTokenizer strTok;
    
    public FastScanner(BufferedReader reader) {
        this.reader = reader;
    }
    
    public String nextToken() throws IOException {
        while (strTok == null || !strTok.hasMoreTokens()) {
            strTok = new StringTokenizer(reader.readLine());
        }
        
        return strTok.nextToken();
    }
    
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    
    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(nextToken());
    }
    
}