Problem: 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.

Solution (in JAVA):

Solution:
/**
 * author: derrick20
 * created: 1/10/21 5:51 PM
 */
import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class DeletingNumbers {
    public static void main(String[] args) {
        sc = new FastScanner();
        out = new PrintWriter(System.out);
        
        int N = sc.nextInt();
        boolean[] composite = new boolean[N + 1];
        ArrayDeque<Integer> small = new ArrayDeque<>();
        ArrayDeque<Integer> large = new ArrayDeque<>();
        int SQRT = (int) sqrt(N);
        for (int i = 2; i <= N; i++) {
            if (!composite[i]) {
                if (i <= SQRT) {
                    small.add(i);
                } else {
                    large.add(i);
                }
                for (int j = i; j <= N; j += i) {
                    composite[j] = true;
                }
            }
        }
        int ans = 1;
        for (int p : small) {
            delete(p);
            int freq = count(p);
            if (freq > 0) {
                int lower = 1;
                int upper = 0;
                int[] pow = new int[18];
                pow[0] = 1;
                while (pow[upper] * p <= N) {
                    pow[upper + 1] = pow[upper] * p;
                    upper++;
                }
                while (lower < upper) {
                    int mid = (lower + upper + 1) / 2;
                    if (count(pow[mid]) > 0) {
                        lower = mid;
                    } else {
                        upper = mid - 1;
                    }
                }
                ans *= pow[upper];
            }
        }
        int block = (int) sqrt(large.size()) + 1;
        // 2 * block operations needed
        ArrayDeque<Integer>[] groups = new ArrayDeque[block];
        // block * block volume = (ceil(sqrt(x))^2 >= x
        Arrays.setAll(groups, i -> new ArrayDeque<>());
        int ix = 0;
        int expectedSize = count(1);
        search: for (int p : large) {
            int cnt = delete(p);
            if (cnt == 2) {
                ans *= p;
                break search;
            }
            expectedSize--;
            groups[ix].add(p);
            if (groups[ix].size() == block || p == large.getLast()) {
                int currSize = count(1);
                if (currSize != expectedSize) {
                    for (int v : groups[ix]) {
                        if (count(v) > 0) {
                            ans *= v;
                            break search;
                        }
                    }
                }
                ix++;
            }
        }
        answer(ans);
        out.close();
    }

    static FastScanner sc;
    static PrintWriter out;
    static int ops;

    static int delete(int a) {
        ops++;
        out.println("B " + a);
        out.flush();
        return sc.nextInt();
    }

    static int count(int a) {
        ops++;
        out.println("A " + a);
        out.flush();
        return sc.nextInt();
    }

    static void answer(int a) {
        ops++;
        out.println("C " + a);
        out.flush();
    }

    static class FastScanner {
        private int BS = 1 << 16;
        private char NC = (char) 0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;
    
        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }
    
        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            } catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }
    
        char getChar() {
            while (bId == size) {
                try {
                    size = in.read(buf);
                } catch (Exception e) {
                    return NC;
                }
                if (size == -1) return NC;
                bId = 0;
            }
            return (char) buf[bId++];
        }
    
        int nextInt() {
            return (int) nextLong();
        }
    
        long nextLong() {
            cnt = 1;
            boolean neg = false;
            if (c == NC) c = getChar();
            for (; (c < '0' || c > '9'); c = getChar()) {
                if (c == '-') neg = true;
            }
            long res = 0;
            for (; c >= '0' && c <= '9'; c = getChar()) {
                res = (res << 3) + (res << 1) + c - '0';
                cnt *= 10;
            }
            return neg ? -res : res;
        }
    
        double nextDouble() {
            boolean neg = false;
            if (c == NC) c = getChar();
            for (; (c < '0' || c > '9'); c = getChar()) {
                if (c == '-') neg = true;
            }
            double cur = nextLong();
            if (c != '.') {
                return neg ? -cur : cur;
            } else {
                double frac = nextLong() / cnt;
                return neg ? -cur - frac : cur + frac;
            }
        }
    
        String next() {
            StringBuilder res = new StringBuilder();
            while (c <= 32) c = getChar();
            while (c > 32) {
                res.append(c);
                c = getChar();
            }
            return res.toString();
        }
    
        String nextLine() {
            StringBuilder res = new StringBuilder();
            while (c <= 32) c = getChar();
            while (c != '\n') {
                res.append(c);
                c = getChar();
            }
            return res.toString();
        }
    
        boolean hasNext() {
            if (c > 32) return true;
            while (true) {
                c = getChar();
                if (c == NC) return false;
                else if (c > 32) return true;
            }
        }
    }
    static void ASSERT(boolean assertion, String message) {
        if (!assertion) throw new AssertionError(message);
    }
    static void ASSERT(boolean assertion) {
        if (!assertion) throw new AssertionError();
    }
}