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.
//package Codeforces.Round670Div2;

import java.util.*;

public class E {
    static ArrayList<Integer> primes;
    /*static class Checker
    {
        int n;
        int guess;
        boolean finishedflag;
        ArrayList<Integer> arr;
        int gcount;
        Checker(int n, int guess)
        {
            this.n = n;
            this.finishedflag = false;
            this.guess = guess;
            this.gcount = 0;
            arr = new ArrayList<>(n+1);
            for(int i=0;i<=n;i++)
            {
                arr.add(i);
            }
        }
        public int println(char c, int a)
        {
            gcount++;
            if(gcount>10000)
            {
                System.out.println("Too many queries");
                System.exit(0);
            }
            if(finishedflag)
            {
                System.out.println("Output wrong in ");
                System.exit(0);
            }

            //System.out.println(c+" "+a);
            if(c == 'A')
            {
                int counter = 0;
                for(int i=a;i<=n;i+=a)
                {
                    if(arr.get(i)!=0)
                        counter++;
                }

                return counter;
            }
            else if(c == 'B')
            {
                int counter = 0;
                for(int i=a;i<=n;i+=a)
                {
                    if(arr.get(i)!=0) {
                        counter++;
                    }

                    if(arr.get(i)!=0 && arr.get(i)!=this.guess)
                    {
                        arr.set(i, 0);
                    }
                }

                return counter;
            }
            else
            {
                if(a==guess) {
                    //System.out.println("Correct Guess. " + a);
                    return 0;
                }
                else
                {
                    System.out.println("Wrong Guess. "+a+" "+this.guess+" "+this.n);
                    System.exit(0);
                }
                finishedflag = true;
                return 0;
            }
        }
    }*/
    public static void preComputePrimes(int n)
    {
        int[] parr = new int[n+1];
        for(int i=0;i<=n;i++)
        {
            parr[i] = i;
        }
        parr[0] = 1;
        for(int i=2;i<=n;i++)
        {
            if(parr[i]==1)
                continue;
            for(int j=2*i;j<=n;j+=i)
            {
                parr[j] = 1;
            }
        }

        for(int i=0;i<=n;i++)
        {
            if(parr[i]!=1)
                primes.add(i);
        }
    }
    /*public static void main(String[] args)
    {
        int t = 10000;
        while(t-->0)
        {
            int n = (int) (Math.random()*100000+1);
            int g = (int) (Math.random()*n+1);
            maind(n, g);

            if(t%100 == 0)
                System.out.println(10000-t);
        }

        System.out.println("Correctly Guessed all test cases");
    }*/
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        //Checker chk = new Checker(n, g);
        int n = sc.nextInt();

        int input;
        primes = new ArrayList<>();
        preComputePrimes(n);
        int numberOfPrimes = primes.size();

        int sqrt = (int) Math.sqrt(n);
        int smallPrimes=0;
        for(int i: primes)
        {
            if(i>sqrt)
                break;
            //input = chk.println('B', i);
            System.out.println("B "+ i);
            System.out.flush();
            input = sc.nextInt();
            smallPrimes++;
        }

        int bigPrimes = numberOfPrimes-smallPrimes;
        //input = chk.println('A', 1);
        System.out.println("A 1");
        System.out.flush();
        input = sc.nextInt();
        input -= 1;

        int ans = 1;
        if(input-bigPrimes==1)
        {
            //Compute for small primes
            ArrayList<Integer> primeFactor = new ArrayList<>();
            for(int ind=0;ind<smallPrimes;ind++)
            {
                int i = primes.get(ind);
                System.out.println("A "+i);
                System.out.flush();
                int k = sc.nextInt();
                //int k = chk.println('A', i);
                if(k==1)
                    primeFactor.add(i);
            }

            for(int i: primeFactor)
            {
                int counter = 1;
                while(true) {
                    if((i*counter) > n)
                        break;
                    //int k = chk.println('A', (i*counter));
                    System.out.println("A "+(i*counter));
                    System.out.flush();
                    int k = sc.nextInt();
                    counter = counter*i;
                    if(k==0)
                        break;
                    else ans *= i;
                }
            }

            /*System.out.println("C "+ans);
            System.out.flush();*/
            //int k = chk.println('C', ans);
        }

        int start = smallPrimes;
        int bsize = 100;
        int prevCount = input;

        while(true)
        {
            //System.out.println(start+" "+primes.get(start));
            if(start+bsize>=primes.size())
            {
                for(int i=start;i<primes.size();i++)
                {
                    int pf = primes.get(i);
                    //input = chk.println('B', pf);
                    System.out.println("B "+pf);
                    System.out.flush();
                    input = sc.nextInt();

                    //input = chk.println('A', pf);
                    System.out.println("A "+pf);
                    System.out.flush();
                    input = sc.nextInt();
                    if(input==1)
                    {
                        System.out.println("C "+(pf*ans));
                        System.out.flush();
                        System.exit(0);
                        //int k = chk.println('C', (pf*ans));
                        return;
                    }
                }
                break;
            }

            int segcount = 0;
            for(int i=start;i<start+bsize;i++)
            {
                int pf = primes.get(i);
                System.out.println("B "+pf);
                System.out.flush();
                input = sc.nextInt();
                //input = chk.println('B', pf);
                segcount += input;
            }
            System.out.println("A 1");
            System.out.flush();
            input = sc.nextInt();
            //input = chk.println('A', 1);
            input -= 1;

            int store = input;
            if(input+segcount != prevCount)
            {
                for(int i=start;i<start+bsize;i++)
                {
                    int pf = primes.get(i);
                    System.out.println("A "+pf);
                    System.out.flush();
                    input = sc.nextInt();
                    //input = chk.println('A', pf);

                    if(input==1)
                    {
                        System.out.println("C "+(pf*ans));
                        System.out.flush();
                        System.exit(0);
                        //input = chk.println('C', (pf*ans));
                        return;
                    }
                }
                break;
            }

            start += bsize;
            prevCount = store;
        }

        System.out.println("C "+ans);
        System.out.flush();
        //chk.println('C', ans);
    }
}