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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 89;
int record[MAXD], rnt;
vector<pair<long long, long long> > factors;
void factor(long long C) {
  factors.resize(0);
  memset(record, 0, sizeof(record));
  long long bound = sqrt(C + 0.5);
  map<int, int> temp;
  map<int, int>::iterator ite;
  for (int i = 2; i <= bound;) {
    if (C % i == 0) {
      ite = temp.find(i);
      if (ite == temp.end())
        temp.insert(make_pair(i, 1));
      else
        ite->second++;
      C /= i;
    } else
      i++;
  }
  if (C != 1) temp.insert(make_pair(C, 1));
  for (ite = temp.begin(); ite != temp.end(); ++ite) {
    factors.push_back(make_pair(ite->first, ite->second));
  }
}
int b, da;
unordered_map<long long, long long> bs, ds;
int ty[120];
int val[120];
int ceil(int val, int b) {
  if (val % b == 0)
    return val / b;
  else
    return val / b + 1;
}
int main() {
  scanf("%d%d", &b, &da);
  factor(b);
  for (int i = (0); i <= ((int)factors.size() - 1); ++i) {
    bs[factors[i].first] = factors[i].second;
  }
  for (int v = (2); v <= (100); ++v) ty[v] = 7;
  for (int d = (2); d <= (100); ++d) {
    factor(d);
    ds.clear();
    for (int j = (0); j <= ((int)factors.size() - 1); ++j) {
      ds[factors[j].first] = factors[j].second;
    }
    bool ok = 1;
    for (auto &ele : ds) {
      int t = ele.first;
      auto ite = bs.find(t);
      if (ite == bs.end()) {
        ok = 0;
        break;
      }
    }
    if (ok) {
      int vv = 1;
      for (auto &ele : ds) {
        int t = ele.first;
        vv = max((long long)vv,
                 max((long long)1, (long long)ceil(ele.second, bs[t])));
      }
      val[d] = vv;
      ty[d] = 2;
    }
  }
  for (int d = (2); d <= (100); ++d) {
    if (ty[d] == 7) {
      if (b % d == 1) ty[d] = 3;
    }
  }
  for (int d = (2); d <= (100); ++d) {
    if (ty[d] == 7) {
      if (b * b % d == 1 && (b + 1) % d == 0) ty[d] = 11;
    }
  }
  for (int d = (2); d <= (100); ++d) {
    if (ty[d] == 7) {
      ds.clear();
      factor(d);
      if (ds.size() == 1)
        continue;
      else {
        rnt = factors.size();
        for (int i = (0); i <= (rnt - 1); ++i) {
          int d = factors[i].first, e = factors[i].second;
          int t = 1;
          while (e--) {
            t *= d;
          }
          record[i] = t;
        }
        bool ok = 1;
        for (int i = (0); i <= (rnt - 1); ++i) {
          if (ty[record[i]] == 7) {
            ok = 0;
            break;
          }
        }
        if (ok) ty[d] = 6;
      }
    }
  }
  if (ty[da] == 2)
    printf("%d-type\n%d\n", 2, val[da]);
  else
    printf("%d-type\n", ty[da]);
  return 0;
}