human
Can you provide a Python code to determine who wins if they both play optimally given the following:
After a long day, Alice and Bob decided to play a little game. The game board consists of n cells in a straight line, numbered from 1 to n, where each cell contains a number a_i between 1 and n. Furthermore, no two cells contain the same number. 

A token is placed in one of the cells. They take alternating turns of moving the token around the board, with Alice moving first. The current player can move from cell i to cell j only if the following two conditions are satisfied: 

  * the number in the new cell j must be strictly larger than the number in the old cell i (i.e. a_j > a_i), and 
  * the distance that the token travels during this turn must be a multiple of the number in the old cell (i.e. |i-j|mod a_i = 0). 


Whoever is unable to make a move, loses. For each possible starting position, determine who wins if they both play optimally. It can be shown that the game is always finite, i.e. there always is a winning strategy for one of the players.

Input

The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of numbers.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n). Furthermore, there are no pair of indices i ≠ j such that a_i = a_j.

Output

Print s — a string of n characters, where the i-th character represents the outcome of the game if the token is initially placed in the cell i. If Alice wins, then s_i has to be equal to "A".
otherwise, s_i has to be equal to "B". 

Examples

Input

8
3 6 5 4 2 7 1 8

Output

BAAAABAB

Input

15
3 11 2 5 10 9 7 13 15 8 4 12 6 1 14

Output

ABAAAABBBAABAAB

Note

In the first sample, if Bob puts the token on the number (not position): 

  * 1: Alice can move to any number. She can win by picking 7, from which Bob has no move. 
  * 2: Alice can move to 3 and 5. Upon moving to 5, Bob can win by moving to 8. If she chooses 3 instead, she wins, as Bob has only a move to 4, from which Alice can move to 8. 
  * 3: Alice can only move to 4, after which Bob wins by moving to 8. 
  * 4, 5, or 6: Alice wins by moving to 8. 
  * 7, 8:...
Using python3 can you solve the prior task?
assistant
#Here is Python code to determine who wins if they both play optimally.

import math
import time
from collections import defaultdict,deque,Counter
from sys import stdin,stdout
from bisect import bisect_left,bisect_right
from queue import PriorityQueue 
import sys
class Graph:
    def __init__(self, n):
        self.graph = defaultdict(lambda: [])
        self.vertices = n
        self.edges = 0
        self.toposorted = []

    def addEdge(self, a, b):  # tested
        self.graph[a].append(b)
        self.edges+=1

    def cycleUntill(self, visited, curr, parent):  # tested
        visited[curr] = True
        for i in self.graph[curr]:
            if(not visited[i]):
                if(self.cycleUntill(visited, i, curr)):
                    return True
            elif(i != parent):
                return True
        return False

    def cycle(self):  # tested
        n = self.vertices
        visited = [False]*(n+2)
        for i in range(1, n+1):
            if(not visited[i]):
                if(self.cycleUntill(visited, i, -1)):
                    return True
        return False

    def topologicalSort(self):#tested
        in_degree = [0]*(self.vertices+10)
        for i in self.graph:
            for j in self.graph[i]:
                in_degree[j] += 1
        queue = deque()
        for i in range(1,self.vertices+1):
            if in_degree[i] == 0:
                queue.append(i)
        cnt = 0
        while queue:
            u = queue.popleft()
            self.toposorted.append(u)
            for i in self.graph[u]:
                in_degree[i] -= 1
                if in_degree[i] == 0:
                    queue.append(i)
            cnt += 1
        if cnt != self.vertices:
            return False
        else:
            return True
    def connected(self):
        visited=[False]*(self.vertices +2)
        ans=[]
        for i in range(1,self.vertices+1):
            if(not visited[i]):
                comp=[]
                q=deque()
                visited[i]=True
                q.append(i)
                while(len(q)>0):
                   ...