This is an interactive problem.

There is an unknown integer x (1≤ x≤ n). You want to find x.

At first, you have a set of integers \{1, 2, …, n\}. You can perform the following operations no more than 10000 times:

  * A a: find how many numbers are multiples of a in the current set. 
  * B a: find how many numbers are multiples of a in this set, and then delete all multiples of a, but x will never be deleted (even if it is a multiple of a). In this operation, a must be greater than 1. 
  * C a: it means that you know that x=a. This operation can be only performed once. 



Remember that in the operation of type B a>1 must hold.

Write a program, that will find the value of x.

Input

The first line contains one integer n (1≤ n≤ 10^5). The remaining parts of the input will be given throughout the interaction process.

Interaction

In each round, your program needs to print a line containing one uppercase letter A, B or C and an integer a (1≤ a≤ n for operations A and C, 2≤ a≤ n for operation B). This line desribes operation you make.

If your operation has type C your program should terminate immediately.

Else your program should read one line containing a single integer, which is the answer to your operation.

After outputting each line, don't forget to flush the output. To do it use:

  * fflush(stdout) in C/C++; 
  * System.out.flush() in Java; 
  * sys.stdout.flush() in Python; 
  * flush(output) in Pascal; 
  * See the documentation for other languages. 



It is guaranteed, that the number x is fixed and won't change during the interaction process.

Hacks:

To make a hack, use such input format:

The only line should contain two integers n, x (1 ≤ x ≤ n ≤ 10^5).

Example

Input


10

2

4

0

Output



B 4

A 2

A 8

C 4

Note

Note that to make the sample more clear, we added extra empty lines. You shouldn't print any extra empty lines during the interaction process.

In the first test n=10 and x=4.

Initially the set is: \{1,2,3,4,5,6,7,8,9,10\}.

In the first operation, you ask how many numbers are multiples of 4 and delete them. The answer is 2 because there are two numbers divisible by 4: \{4,8\}. 8 will be deleted but 4 won't, because the number x will never be deleted. Now the set is \{1,2,3,4,5,6,7,9,10\}.

In the second operation, you ask how many numbers are multiples of 2. The answer is 4 because there are four numbers divisible by 2: \{2,4,6,10\}.

In the third operation, you ask how many numbers are multiples of 8. The answer is 0 because there isn't any number divisible by 8 in the current set.

In the fourth operation, you know that x=4, which is the right answer.
import org.omg.CORBA.MARSHAL;

import java.math.BigInteger;
import java.util.*;
import java.io.*;

public class Main {
    static ArrayList<Integer> primes;
    static int[] isComposite;

    static void sieve(int N)	// O(N log log N)
    {
        isComposite = new int[N+1];
        isComposite[0] = isComposite[1] = 1;			// 0 indicates a prime number
        primes = new ArrayList<Integer>();

        for (int i = 2; i <= N; ++i) 					//can loop till i*i <= N if primes array is not needed O(N log log sqrt(N))
            if (isComposite[i] == 0) 					//can loop in 2 and odd integers for slightly better performance
            {
                primes.add(i);
                if(1l * i * i <= N)
                    for (int j = i * i; j <= N; j += i)	// j = i * 2 will not affect performance too much, may alter in modified sieve
                        isComposite[j] = 1;
            }
    }
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = sc.nextInt();
        sieve(n);
        ArrayList<Integer>sq= new ArrayList<>();
        for (int i =0;i<primes.size();i++){
            if (primes.get(i)*primes.get(i)>n)
                break;
            sq.add(primes.get(i));
        }
        for (int i=0;i<sq.size();i++){
            pw.println("B "+sq.get(i));
            pw.flush();
            sc.nextInt();
        }
        long ans=1;
        for (int i =0;i<sq.size();i++){
            long cur=sq.get(i);
            while (cur<=n){
                pw.println("B "+cur);
                pw.flush();
                int x = sc.nextInt();
                if (x==0)
                    break;
                cur*=sq.get(i);
            }
            cur/=sq.get(i);
            ans*=cur;
        }
        if(ans==1){
            int all=primes.size()-sq.size()+1;
            for (int i =sq.size();i<primes.size()&&ans==1;i++){

                for (int j =i;j<primes.size()&&j-i<=100;j++){
                    pw.println("B "+primes.get(j));
                    pw.flush();
                    sc.nextInt();
                    all--;
                }
                pw.println("A 1");
                pw.flush();
                int c= sc.nextInt();
                if (c>all){
                    for (int j =i;j<primes.size()&&j-i<=100;j++){
                        pw.println("A "+primes.get(j));
                        pw.flush();
                        if (sc.nextInt()>0){
                            ans*=primes.get(j);
                            break;
                        }
                    }
                }
                i+=100;
            }
        }
        else {
            for (int i =sq.size();i<primes.size();i++){
                pw.println("A "+primes.get(i));
                pw.flush();
                if (sc.nextInt()>1){
                    ans*=primes.get(i);
                    break;
                }
            }
        }
        pw.println("C "+ans);
        pw.flush();

    }
    static class Scanner {
        BufferedReader br;
        StringTokenizer st;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader f) {
            br = new BufferedReader(f);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public int[] nextIntArr(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = Integer.parseInt(next());
            }
            return arr;
        }

    }

}