Bitland declared war on Chefland and sent an army to fight them, but Chefland defended efficiently and Bitland's army has been reduced to N$N$ soldiers. They have no chance of winning the war and do not want to surrender, so they are planning to commit group suicide. Josh, the leader of Bitland's remaining soldiers, has different plans — he wants to survive and somehow escape.
The soldiers are numbered 1$1$ through N$N$; Josh is soldier N$N$. The soldiers are going to stand in a circle in the order 1,2,…,P−1,N,P,P+1,…,N−1$1, 2, \ldots, P-1, N, P, P+1, \ldots, N-1$. Formally, they are standing in the circle in such a way that if Josh's position is P$P$ (1≤P≤N$1 \le P \le N$), then for each i$i$ (1≤i≤N−2$1 \le i \le N-2$, i≠P−1$i \neq P-1$), soldier i+1$i+1$ is directly to the right of soldier i$i$, soldier P$P$ (if P≤N−1$P \le N-1$) or 1$1$ (if P=N$P = N$) is directly to the right of Josh and Josh is directly to the right of soldier P−1$P-1$ (if P≥2$P \ge 2$) or soldier N−1$N-1$ (if P=1$P = 1$); if 2≤P≤N−2$2 \le P \le N-2$, soldier 1$1$ is also directly to the right of soldier N−1$N-1$. For each i$i$ (1≤i≤N−1$1 \le i \le N-1$), soldier i$i$ has a sword with power Ai$A_i$. Josh plans to take a shield with sufficiently high defense power D$D$.
First, the soldiers start to commit group suicide according to the following rules:
- Initially, soldier 1$1$ is the attacking soldier.
- If the attacking soldier is not Josh, this soldier attacks the soldier that is currently to his right.
- When Josh is attacked with power a$a$, the current defense power of his shield decreases by a$a$, and if it becomes negative, Josh dies. When a different soldier is attacked, he does not try to defend and dies immediately. The power of the attacking soldier's sword does not change.
- Then, the next living soldier to the right of the current attacking soldier becomes the attacking soldier and the process continues until there is only one soldier left.
It is clear that this way, Josh cannot be the last survivor. However, Chefland's general Chef plans to interrupt this process as soon as there are exactly two living soldiers of Bitland left (Josh wants to be one of them) by attacking them with Chefland's full firepower F$F$. Since this attack is unexpected, both attacked soldiers try to defend independently with the weapons they have. Josh survives if the current defense power of his shield is at least F$F$. Any other soldier survives only if the power of his sword is strictly greater than F$F$. Since Chefland does not attack again, if both Josh and another soldier survive, then the other soldier will kill Josh. Therefore, Josh wants to be the only survivor of Chefland's attack.
Your task is to find the minimum possible value of D$D$ such that Josh survives if he chooses his position P$P$ optimally (or determine that he cannot survive) and the lowest position P$P$ such that Josh survives if he takes a shield with this defense power D$D$.

-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains a single integer N$N$.
- The second line contains N−1$N-1$ space-separated integers A1,A2,…,AN−1$A_1, A_2, \ldots, A_{N-1}$.
- The third line contains a single integer F$F$.

-----Output-----
For each test case, first, print a line containing the string "possible" if Josh can survive or "impossible" if he cannot (without quotes). Then, if he can survive, print a second line containing two space-separated integers P$P$ and D$D$.

-----Constraints-----
- 1≤T≤1,000$1 \le T \le 1,000$
- 2≤N≤1,000,000$2 \le N \le 1,000,000$
- 1≤Ai≤10,000$1 \le A_i \le 10,000$ for each valid i$i$
- 1≤F≤10,000$1 \le F \le 10,000$
- the sum of N$N$ over all test cases does not exceed 1,000,005$1,000,005$

-----Subtasks-----
Subtask #1 (30 points):
- 1≤T≤10$1 \le T \le 10$
- 2≤N≤100$2 \le N \le 100$
- 1≤Ai≤100$1 \le A_i \le 100$ for each valid i$i$
- 1≤F≤100$1 \le F \le 100$
Subtask #2 (70 points): original constraints

-----Example Input-----
2
5
12 34 45 5
10
5
10 15 43 20
5

-----Example Output-----
possible
4 100
impossible

-----Explanation-----
Example case 1: When Josh is at the position P=4$P = 4$, the soldiers' initial powers in clockwise order around the circle, starting with soldier 1$1$, are [12,34,45,D,5]$[12, 34, 45, D, 5]$ (D$D$ denotes Josh). Then, the following happens:
- The soldier with power 12$12$ attacks the soldier with power 34$34$ and kills him.
- The soldier with power 45$45$ attacks Josh, who defends. The living soldiers' powers are now [12,45,D−45,5]$[12, 45, D-45, 5]$ and Josh is the attacking soldier.
- Josh does not attack, so the soldier to his right (with power 5$5$) becomes the attacking soldier. He attacks the soldier with power 12$12$ and kills him.
- The soldier with power 45$45$ attacks Josh again and Josh defends again.
- The soldier with power 5$5$ attacks the soldier with power 45$45$ and kills him.
- Now, two soldiers are left: Josh (with a shield with defense power D−90$D-90$) and the soldier with a sword with power 5$5$. Each of them is attacked with firepower F=10$F=10$, so the power of Josh's shield drops to D−100$D-100$ and the other soldier dies.
If Josh survives, his shield's initial power D$D$ should be at least 45+45+10=100$45+45+10 = 100$. For all other positions P$P$, Josh cannot survive.
Example case 2: Regardless of how large D$D$ is and which position Josh chooses, after Chefland's attack, a soldier of Bitland other than Josh will always survive. This soldier will then attack Josh until his shield breaks and he dies.

Difficulty: interview

Starter code:

Solutions:
import numpy as np
for _ in range(int(input())):
   n = int(input())-1;soldiers = [int(j) for j in input().split()]
   force = int(input());attacks = np.zeros(2*n,dtype=int);attacks[:n] = np.array(soldiers);attacks[n:2*n] = attacks[:n];shield = [0 for _ in range(n)];pow_of_2 = 1
   while n // pow_of_2 > 0:      pow_of_2 *= 2
   soldier_of_attack = (2 * n - pow_of_2) % n;pow_of_2 = attacks[soldier_of_attack] > force
   
   for i in range(n):
      if attacks[i] > force:         shield[i] = 10 ** 11
      elif n == 1:         shield[i] = force
      elif pow_of_2:
         shield[i] = force;         num_of_survivors = n;  soldiers = list(attacks[i:i+n]);         starting_soldier = (n - i) % n
         if (num_of_survivors - starting_soldier) % 2 == 1:            shield[i] += soldiers[-1]
         soldiers = [soldiers[i] for i in range(num_of_survivors) if i < starting_soldier or (i - starting_soldier) % 2 == 0];num_of_survivors = starting_soldier + (num_of_survivors - starting_soldier - 1) // 2
         if num_of_survivors > 1:
            pow_2 = 1
            while True:
               attacker = num_of_survivors - (num_of_survivors % pow_2);   pow_2 *= 2
               if attacker == 0:                  break
               if attacker % pow_2 == 0:                  shield[i] += soldiers[attacker]
      elif i == soldier_of_attack:         shield[i] = force
      else:         shield[i] = force + 1   
   shield_needed = min(shield)
   if shield_needed == 10 ** 11:      print("impossible")
   else:
      print("possible")
      for i in range(n):
         if shield[i] == shield_needed:print(str(i+1) + " " + str(shield_needed));break

# cook your dish here
import numpy as np
tests = int(input())
for _ in range(tests):
   n = int(input())-1
   soldiers = [int(j) for j in input().split()]
   force = int(input())
   attacks = np.zeros(2*n,dtype=int)
   attacks[:n] = np.array(soldiers)
   attacks[n:2*n] = attacks[:n]
   shield = [0 for _ in range(n)]
   
   pow_of_2 = 1
   while n // pow_of_2 > 0:
      pow_of_2 *= 2
   soldier_of_attack = (2 * n - pow_of_2) % n
   pow_of_2 = attacks[soldier_of_attack] > force
   
   for i in range(n):
      if attacks[i] > force:
         shield[i] = 10 ** 11
      elif n == 1:
         shield[i] = force
      elif pow_of_2:
         shield[i] = force
         num_of_survivors = n
         soldiers = list(attacks[i:i+n])
         starting_soldier = (n - i) % n
         if (num_of_survivors - starting_soldier) % 2 == 1:
            shield[i] += soldiers[-1]
         soldiers = [soldiers[i] for i in range(num_of_survivors) if i < starting_soldier or (i - starting_soldier) % 2 == 0]
         num_of_survivors = starting_soldier + (num_of_survivors - starting_soldier - 1) // 2
         if num_of_survivors > 1:
            pow_2 = 1
            while True:
               attacker = num_of_survivors - (num_of_survivors % pow_2)
               pow_2 *= 2
               if attacker == 0:
                  break
               if attacker % pow_2 == 0:
                  shield[i] += soldiers[attacker]
      elif i == soldier_of_attack:
         shield[i] = force
      else:
         shield[i] = force + 1
   
   shield_needed = min(shield)
   if shield_needed == 10 ** 11:
      print("impossible")
   else:
      print("possible")
      for i in range(n):
         if shield[i] == shield_needed:
            print(str(i+1) + " " + str(shield_needed))
            break

# cook your dish here
import numpy as np
tests = int(input())
for _ in range(tests):
   n = int(input())-1
   soldiers = [int(j) for j in input().split()]
   force = int(input())
   attacks = np.zeros(2*n,dtype=int)
   attacks[:n] = np.array(soldiers)
   attacks[n:2*n] = attacks[:n]
   shield = [0 for _ in range(n)]
   
   for i in range(n):
      if attacks[i] > force:
         shield[i] = 10 ** 11
      elif n == 1:
         shield[i] = force
      else:
         shield[i] = force
         num_of_survivors = n
         soldiers = list(attacks[i:i+n])
         starting_soldier = (n - i) % n
         if (num_of_survivors - starting_soldier) % 2 == 1:
            shield[i] += soldiers[-1]
         soldiers = [soldiers[i] for i in range(num_of_survivors) if i < starting_soldier or (i - starting_soldier) % 2 == 0]
         num_of_survivors = starting_soldier + (num_of_survivors - starting_soldier - 1) // 2
         if num_of_survivors > 1:
            pow_2 = 1
            while True:
               attacker = num_of_survivors - (num_of_survivors % pow_2)
               pow_2 *= 2
               if attacker == 0:
                  break
               if attacker % pow_2 == 0:
                  shield[i] += soldiers[attacker]
   
   shield_needed = min(shield)
   if shield_needed == 10 ** 11:
      print("impossible")
   else:
      print("possible")
      for i in range(n):
         if shield[i] == shield_needed:
            print(str(i+1) + " " + str(shield_needed))
            break

# cook your dish here
import numpy as np
tests = int(input())
for _ in range(tests):
   n = int(input())-1
   soldiers = [int(j) for j in input().split()]
   force = int(input())
   attacks = np.zeros(2*n,dtype=int)
   attacks[:n] = np.array(soldiers)
   attacks[n:2*n] = attacks[:n]
   shield = [0 for _ in range(n)]
   for i in range(n):
      if attacks[i] > force:
         shield[i] = 10 ** 11
      else:
         shield[i] = force
         num_of_survivors = n
         soldiers = list(attacks[i:i+n])
         starting_soldier = (n - i) % n
         while num_of_survivors > 1:
            if (num_of_survivors - starting_soldier) % 2 == 1:
               shield[i] += soldiers[-1]
            soldiers = [soldiers[i] for i in range(num_of_survivors) if i < starting_soldier or (i - starting_soldier) % 2 == 0]
            num_of_survivors = starting_soldier + (num_of_survivors - starting_soldier + 1) // 2
            starting_soldier = 0
   shield_needed = min(shield)
   if shield_needed == 10 ** 11:
      print("impossible")
   else:
      print("possible")
      for i in range(n):
         if shield[i] == shield_needed:
            print(str(i+1) + " " + str(shield_needed))
            break

def fun(l,n,i):
    ans=0
    no_term=n-i+1 + i//2
    side=i+(no_term-1)
    if side>n:
        side=2*(side-n)-1
    count=0
    power=1
    if i%2==0:
        ans+=l[side-1]
    while(side!=i):
        if no_term%2==0:
            no_term=no_term//2
            #count+=1
            power*=2
        else:
            no_term=(no_term//2)+1
            ans+=l[side-1]
            #count+=1
            power*=2

        side=i+(no_term-1)*power
        if side>n:
            side=2*(side-n)-1
    return ans
for _ in range(int(input())):
    n=int(input())
    l=list(map(int,input().split()))
    f=int(input())
    ans=[]
    c=0
    count=0
    P=None
    for i in range(len(l)):
        if l[i]<=f :
            c=1
            if count==0:
                count+=1
                D=fun(l,n-1,i+1)
                P=i+1
            else:
                yt=fun(l,n-1,i+1)
                if yt<D:
                    P=i+1
                    D=yt
    if c==0:
        print('impossible')
    else:
        print('possible')
        print(P,D+f)

# cook your dish here
def fun(l,n,i):
    ans=0
    no_term=n-i+1 + i//2
    side=i+(no_term-1)
    if side>n:
        side=2*(side-n)-1
    count=0
    power=1
    if i%2==0:
        ans+=l[side-1]
    while(side!=i):
        if no_term%2==0:
            no_term=no_term//2
            #count+=1
            power*=2
        else:
            no_term=(no_term//2)+1
            ans+=l[side-1]
            #count+=1
            power*=2

        side=i+(no_term-1)*power
        if side>n:
            side=2*(side-n)-1
    return ans
for _ in range(int(input())):
    n=int(input())
    l=list(map(int,input().split()))
    f=int(input())
    ans=[]
    c=0
    count=0
    P=None
    for i in range(len(l)):
        if l[i]<=f :
            c=1
            if count==0:
                count+=1
                D=fun(l,n-1,i+1)
                P=i+1
            else:
                yt=fun(l,n-1,i+1)
                if yt<D:
                    P=i+1
                    D=yt
    if c==0:
        print('impossible')
    else:
        print('possible')
        print(P,D+f)


# cook your dish here
def fun(l,n,i):
    ans=0
    no_term=n-i+1 + i//2
    side=i+(no_term-1)
    if side>n:
        side=2*(side-n)-1
    count=0
    power=1
    if i%2==0:
        ans+=l[side-1]
    while(side!=i):
        if no_term%2==0:
            no_term=no_term//2
            #count+=1
            power*=2
        else:
            no_term=(no_term//2)+1
            ans+=l[side-1]
            #count+=1
            power*=2

        side=i+(no_term-1)*power
        if side>n:
            side=2*(side-n)-1
    return ans
for _ in range(int(input())):
    n=int(input())
    l=list(map(int,input().split()))
    f=int(input())
    ans=[]
    c=0
    count=0
    P=None
    for i in range(len(l)):
        if l[i]<=f :
            c=1
            if count==0:
                count+=1
                D=fun(l,n-1,i+1)
                P=i+1
            else:
                yt=fun(l,n-1,i+1)
                if yt<D:
                    P=i+1
                    D=yt
    if c==0:
        print('impossible')
    else:
        print('possible')
        print(P,D+f)


# cook your dish here
def solve_small(numbers, n, f):

    found = False
    min_shield = 0
    min_pos = 0
    for pos in range(n):
        # First optimization
        next_pos0 = pos % (n - 1)
        # print(pos, next_pos0)
        if numbers[next_pos0] > f:
            continue

        new_numbers = [_ for _ in numbers]
        new_numbers.insert(pos, 0)
        #print("new numbers: ",new_numbers, next_pos0)

        curr_pos = 0
        # round = 1
        while len(new_numbers) > 2:
            next_pos = (curr_pos + 1) % len(new_numbers)
            # print("Round {}: {}, {}, {}".format(round, curr_pos, next_pos, new_numbers))
            if new_numbers[next_pos] <= 0:
                # print("Attacked Josh from {} to {}".format(curr_pos, next_pos))
                new_numbers[next_pos] -= new_numbers[curr_pos]
            elif new_numbers[curr_pos] > 0:
                # print("Killed soldier from {} to {}".format(curr_pos, next_pos))
                new_numbers.pop(next_pos)
            else:
                # print("Josh does not attack")
                pass
            if curr_pos >= len(new_numbers) - 1:
                curr_pos = 0
            else:
                curr_pos += 1
            # print("Round {}: {}, {}".format(round, curr_pos, new_numbers))
            # round += 1

        # print(new_numbers, f)
        shield, min_f = -min(new_numbers), max(new_numbers)

        # Other soldier will survive
        if min_f > f:
            continue

        # Only Josh survives
        shield += f
        found = True
        if not min_shield or min_shield > shield:
            min_shield = shield
            min_pos = pos

    if found:
        print("possible")
        return min_pos + 1, min_shield
    else:
        print("impossible")
        return 0, 0
def solve_med(numbers, n, f):

    min_shield = 0
    min_pos = 0
    left_numbers = []
    right_numbers = [0] + [_ for _ in numbers]

    for pos in range(0, n):

        right_numbers.pop(0)
        if pos % 2:
            left_numbers.append(numbers[pos - 1])

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        new_numbers = right_numbers + left_numbers
        jos_pos = len(new_numbers)

        new_pos = jos_pos
        factor = 2
        while new_pos > 1:
            if new_pos % 2:
                number = new_numbers[get_prev_multiple(jos_pos, factor)]
                number2 = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                # print(number, number2)
                shield += number
                # shield += new_numbers[get_prev_multiple(jos_pos, factor)]
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
def get_prev_multiple_2(n, pos, f):

    left_numbers = (pos - 1) // 2
    right_numbers = n - pos
    total_numbers = left_numbers + right_numbers
    number = total_numbers - total_numbers % f
    if number >= right_numbers:
        number = number - right_numbers
        return 2 * number
    else:
        return pos + number
def get_prev_multiple(n, f):
    return (n - 1) - (n - 1) % f
def get_input_line():
    return input()
def solve_big(numbers, n, f):

    min_shield = 0
    min_pos = 0
    for pos in range(0, n):

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        jos_pos = (pos - 1) // 2 + n - pos

        new_pos = jos_pos
        factor = 2
        over = False
        while new_pos > 1:
            if new_pos % 2:
                number = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                shield += number
                if min_shield and shield >= min_shield:
                    over = True
                    break
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if over:
            continue

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
t=int(input())
for i in range(t):
    n=int(input())
    numbers=list(map(int,input().split(" ")))
    f=int(input())
    min_pos, min_shield = solve_med(numbers, n, f)
    if min_shield:
        print(min_pos, min_shield)
    


# cook your dish here
def solve_small(numbers, n, f):

    found = False
    min_shield = 0
    min_pos = 0
    for pos in range(n):
        # First optimization
        next_pos0 = pos % (n - 1)
        # print(pos, next_pos0)
        if numbers[next_pos0] > f:
            continue

        new_numbers = [_ for _ in numbers]
        new_numbers.insert(pos, 0)
        #print("new numbers: ",new_numbers, next_pos0)

        curr_pos = 0
        # round = 1
        while len(new_numbers) > 2:
            next_pos = (curr_pos + 1) % len(new_numbers)
            # print("Round {}: {}, {}, {}".format(round, curr_pos, next_pos, new_numbers))
            if new_numbers[next_pos] <= 0:
                # print("Attacked Josh from {} to {}".format(curr_pos, next_pos))
                new_numbers[next_pos] -= new_numbers[curr_pos]
            elif new_numbers[curr_pos] > 0:
                # print("Killed soldier from {} to {}".format(curr_pos, next_pos))
                new_numbers.pop(next_pos)
            else:
                # print("Josh does not attack")
                pass
            if curr_pos >= len(new_numbers) - 1:
                curr_pos = 0
            else:
                curr_pos += 1
            # print("Round {}: {}, {}".format(round, curr_pos, new_numbers))
            # round += 1

        # print(new_numbers, f)
        shield, min_f = -min(new_numbers), max(new_numbers)

        # Other soldier will survive
        if min_f > f:
            continue

        # Only Josh survives
        shield += f
        found = True
        if not min_shield or min_shield > shield:
            min_shield = shield
            min_pos = pos

    if found:
        print("possible")
        return min_pos + 1, min_shield
    else:
        print("impossible")
        return 0, 0
def solve_med(numbers, n, f):

    min_shield = 0
    min_pos = 0
    left_numbers = []
    right_numbers = [0] + [_ for _ in numbers]

    for pos in range(0, n):

        right_numbers.pop(0)
        if pos % 2:
            left_numbers.append(numbers[pos - 1])

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        new_numbers = right_numbers + left_numbers
        jos_pos = len(new_numbers)

        new_pos = jos_pos
        factor = 2
        while new_pos > 1:
            if new_pos % 2:
                number = new_numbers[get_prev_multiple(jos_pos, factor)]
                number2 = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                # print(number, number2)
                shield += number
                # shield += new_numbers[get_prev_multiple(jos_pos, factor)]
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
def get_prev_multiple_2(n, pos, f):

    left_numbers = (pos - 1) // 2
    right_numbers = n - pos
    total_numbers = left_numbers + right_numbers
    number = total_numbers - total_numbers % f
    if number >= right_numbers:
        number = number - right_numbers
        return 2 * number
    else:
        return pos + number
def get_prev_multiple(n, f):
    return (n - 1) - (n - 1) % f
def get_input_line():
    return input()
def solve_big(numbers, n, f):

    min_shield = 0
    min_pos = 0
    for pos in range(0, n):

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        jos_pos = (pos - 1) // 2 + n - pos

        new_pos = jos_pos
        factor = 2
        over = False
        while new_pos > 1:
            if new_pos % 2:
                number = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                shield += number
                if min_shield and shield >= min_shield:
                    over = True
                    break
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if over:
            continue

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
t=int(input())
for i in range(t):
    n=int(input())
    numbers=list(map(int,input().split(" ")))
    f=int(input())
    min_pos, min_shield = solve_small(numbers, n, f)
    if min_shield:
        print(min_pos, min_shield)
    


# cook your dish here
def solve_small(numbers, n, f):

    found = False
    min_shield = 0
    min_pos = 0
    for pos in range(n):
        # First optimization
        next_pos0 = pos % (n - 1)
        # print(pos, next_pos0)
        if numbers[next_pos0] > f:
            continue

        new_numbers = [_ for _ in numbers]
        new_numbers.insert(pos, 0)
        #print("new numbers: ",new_numbers, next_pos0)

        curr_pos = 0
        # round = 1
        while len(new_numbers) > 2:
            next_pos = (curr_pos + 1) % len(new_numbers)
            # print("Round {}: {}, {}, {}".format(round, curr_pos, next_pos, new_numbers))
            if new_numbers[next_pos] <= 0:
                # print("Attacked Josh from {} to {}".format(curr_pos, next_pos))
                new_numbers[next_pos] -= new_numbers[curr_pos]
            elif new_numbers[curr_pos] > 0:
                # print("Killed soldier from {} to {}".format(curr_pos, next_pos))
                new_numbers.pop(next_pos)
            else:
                # print("Josh does not attack")
                pass
            if curr_pos >= len(new_numbers) - 1:
                curr_pos = 0
            else:
                curr_pos += 1
            # print("Round {}: {}, {}".format(round, curr_pos, new_numbers))
            # round += 1

        # print(new_numbers, f)
        shield, min_f = -min(new_numbers), max(new_numbers)

        # Other soldier will survive
        if min_f > f:
            continue

        # Only Josh survives
        shield += f
        found = True
        if not min_shield or min_shield > shield:
            min_shield = shield
            min_pos = pos

    if found:
        print("possible")
        return min_pos + 1, min_shield
    else:
        print("impossible")
        return 0, 0
def solve_med(numbers, n, f):

    min_shield = 0
    min_pos = 0
    left_numbers = []
    right_numbers = [0] + [_ for _ in numbers]

    for pos in range(0, n):

        right_numbers.pop(0)
        if pos % 2:
            left_numbers.append(numbers[pos - 1])

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        new_numbers = right_numbers + left_numbers
        jos_pos = len(new_numbers)

        new_pos = jos_pos
        factor = 2
        while new_pos > 1:
            if new_pos % 2:
                number = new_numbers[get_prev_multiple(jos_pos, factor)]
                number2 = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                # print(number, number2)
                shield += number
                # shield += new_numbers[get_prev_multiple(jos_pos, factor)]
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
def get_prev_multiple_2(n, pos, f):

    left_numbers = (pos - 1) // 2
    right_numbers = n - pos
    total_numbers = left_numbers + right_numbers
    number = total_numbers - total_numbers % f
    if number >= right_numbers:
        number = number - right_numbers
        return 2 * number
    else:
        return pos + number
def get_prev_multiple(n, f):
    return (n - 1) - (n - 1) % f
def get_input_line():
    return input()
def solve_big(numbers, n, f):

    min_shield = 0
    min_pos = 0
    for pos in range(0, n):

        # First optimization - if next number is to big, it won't die in the end
        next_pos0 = pos % (n - 1)
        if numbers[next_pos0] > f:
            continue

        # Initial shield
        shield = f
        if pos % 2:
            shield += numbers[pos - 1]

        jos_pos = (pos - 1) // 2 + n - pos

        new_pos = jos_pos
        factor = 2
        over = False
        while new_pos > 1:
            if new_pos % 2:
                number = numbers[get_prev_multiple_2(n - 1, pos, factor)]
                shield += number
                if min_shield and shield >= min_shield:
                    over = True
                    break
                # print(factor, get_prev_multiple(jos_pos, factor))
            new_pos = new_pos // 2 + (new_pos % 2)
            factor *= 2

        if over:
            continue

        if not min_shield or shield < min_shield:
            min_shield = shield
            min_pos = pos + 1

    if min_shield:
        print("possible")
    else:
        print("impossible")

    return min_pos, min_shield
t=int(input())
for i in range(t):
    n=int(input())
    numbers=list(map(int,input().split(" ")))
    f=int(input())
    min_pos, min_shield = solve_big(numbers, n, f)
    if min_shield:
        print(min_pos, min_shield)
    


# cook your dish here
def solution(a,n,f):
        idxs = []
        i = 0
        while i < n - 1:
            if a[i] <= f:
                idxs.append(i)
            i += 1
        if len(idxs) == 0:
            print("impossible")
            return
        mn = 1000000000
        for k in idxs:
            left = k
            pts = 0 
            elm = left - 1
            right = n - 1 - left
            last = n - 2
            sub = a[elm]
            sleft = 1
            slast = 1
            while left > 0:
                if left % 2 == 0:
                    elm -= sleft
                    sub = a[elm]
                    left = left//2
                    sleft *= 2
                else:
                    pts += a[elm]
                    left = (left+1)//2
                    sleft *= 2
                
                if right % 2 == 0:
                    last -= slast
                    right //= 2
                    slast *=2
                else:
                    slast *= 2
                    left -= 1
                    right = (right + 1) // 2
                    
            while right > 2:
                if right % 2 == 0:
                    last -= slast
                    sub = a[last]
                    right = right // 2
                    slast *= 2
                else:
                    slast *= 2
                    sub = a[last]
                    pts += sub
                    right = (right + 1) // 2
            if mn > pts:
                mn = pts
                idx = k
                if pts == 0:
                    break
        print("possible")
        print(idx + 1,mn + f)

def main():
    for _ in range(int(input())):
        n = int(input())
        a = list(map(int,input().split()))
        f = int(input())
        solution(a,n,f)
main()

# cook your dish here
def main():
    for _ in range(int(input())):
        n = int(input())
        a = list(map(int,input().split()))
        f = int(input())
        idxs = []
        i = 0
        while i < n - 1:
            if a[i] <= f:
                idxs.append(i)
            i += 1
        if len(idxs) == 0:
            print("impossible")
            continue
        mn = 1000000000
        for k in idxs:
            left = k
            pts = 0 
            elm = left - 1
            right = n - 1 - left
            last = n - 2
            sub = a[elm]
            sleft = 1
            slast = 1
            while left > 0:
                if left % 2 == 0:
                    elm -= sleft
                    sub = a[elm]
                    left = left//2
                    sleft *= 2
                else:
                    pts += a[elm]
                    left = (left+1)//2
                    sleft *= 2
                
                if right % 2 == 0:
                    last -= slast
                    right //= 2
                    slast *=2
                else:
                    slast *= 2
                    left -= 1
                    right = (right + 1) // 2
                    
            while right > 2:
                if right % 2 == 0:
                    last -= slast
                    sub = a[last]
                    right = right // 2
                    slast *= 2
                else:
                    slast *= 2
                    sub = a[last]
                    pts += sub
                    right = (right + 1) // 2
            if mn > pts:
                mn = pts
                idx = k
                if pts == 0:
                    break
        print("possible")
        print(idx + 1,mn + f)
main()

# cook your dish here
import sys
for _ in range(int(input())):
    n = int(input())
    a = list(map(int,sys.stdin.readline().split()))
    f = int(input())
    idxs = []
    i = 0
    while i < n - 1:
        if a[i] <= f:
            idxs.append(i)
        i += 1
    if len(idxs) == 0:
        print("impossible")
        continue
    mn = 1000000000
    for k in idxs:
        left = k
        pts = 0 
        elm = left - 1
        right = n - 1 - left
        last = n - 2
        sub = a[elm]
        sleft = 1
        slast = 1
        while left > 0:
            if left % 2 == 0:
                elm -= sleft
                sub = a[elm]
                left = left//2
                sleft *= 2
            else:
                pts += a[elm]
                left = (left+1)//2
                sleft *= 2
            
            if right % 2 == 0:
                last -= slast
                right //= 2
                slast *=2
            else:
                slast *= 2
                left -= 1
                right = (right + 1) // 2
                
        while right > 2:
            if right % 2 == 0:
                last -= slast
                sub = a[last]
                right = right // 2
                slast *= 2
            else:
                slast *= 2
                sub = a[last]
                pts += sub
                right = (right + 1) // 2
        if mn > pts:
            mn = pts
            idx = k
            if pts == 0:
                break
    print("possible")
    print(idx + 1,mn + f)

p2=[1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152,4194304,8388608,16777216]
for _ in range(int(input())):
	n=int(input())-1
	a=[int(x) for x in input().split()]
	f,l=int(input()),[]
	for i in range(n):
		if a[i]<=f: l.append(i)
		if i%2==0: a.append(a[i])
	if len(l)==0:
		print("impossible")
		continue
	print("possible")
	d,p=10**12,-1
#	print(*a)
	for i in l:
		x=-1+n-i+(i+1)//2
		last=i+x
		td=f
		if i%2==1: td+=a[i-1]
		for j in range(1,25):
			if p2[j]>x: break
			la=last-x%p2[j]
			if la+p2[j-1]>last: td+=a[la]
		if td<d: d,p=td,i+1
	print(p,d)


from sys import stdin
from math import ceil

def func(arr):
    step=0
    right=len(arr)-1
    n=len(arr)
    while(right!=1):
        step+=1
        if n%2!=0:
            right-=(2**(step-1))
        else:
            arr[0]-=arr[right]
        n=ceil((n-1)/2)+1
    return arr[0]    

for _ in range(int(stdin.readline())):
    n=int(stdin.readline())
    arr=list(map(int,stdin.readline().split()))
    f=int(stdin.readline())
    indexes=[i for i,x in enumerate(arr) if x<=f]
    if len(indexes)==0:
        print("impossible")
    else:
        print("possible")
        final={}
        for ele in indexes:
            part=arr[0:ele]
            p=len(part)
            part=part[0:p:2]
            if p%2!=0:
                part.append(0-part[-1])
            else:
                part.append(0)
            case=arr[ele:]+part
            ans=[case[-1]]+case[0:len(case)-1]
            m=abs(func(ans))
            if m in final:
                final[m].append(ele)
            else:
                final[m]=[ele]   
        print(min(final[min(list(final.keys()))])+1,min(list(final.keys()))+f)


try:
    t=int(input())
    for i in range(t):
        
        
        n=int(input())
        a=list(map(int,input().split()))
        a1=a.copy()
        #print("a1==",a1)
        f=int(input())
        length_a=len(a)
        #print(min(l))
        l1=[]
        l2=[]
        
        
        
        
        for j in range(length_a+1):
                a=a1.copy()
                
                #print("1st line with j",a,j)
                l=['D',0,0]
                a.insert(j,l)
                k=0
                l[2]=j+1
                #print(a)
                while len(a) !=2:
                    length=len(a)
                    #print("****",length,k)
                    if k>=length:
                        k=0
                    if a[k]==l:
                        k=k+1
                        #print("skipped")
                        continue
                    else:
                        m=k+1
                        if m>=length:
                            m=0
                        if a[m]==l:
                            l[1]+=a[k]
                        else:
                            del a[m]
                            #print("a[m] wala",a)
                        k+=1
                    
                '''if len(a)==2:
                    if a[0]==l:
                        l[1]+=f
                    else:
                        a[1]=a[1]-f
                        
                    if a[1]==l:
                        l[1]+=f
                    else:
                        a[0]=a[0]-f
                        if a[0]<0:
                            l1.append(l)
                ''' 
                
                if a[0]==l:
                    l[1]+=f
                        
                else:
                        a[0]=a[0]-f
                if a[1]==l:
                    l[1]+=f
                        
                else:
                        a[1]=a[1]-f
                #print("z wala loop",a)
                
                if a[0]!=l:
                        if a[0]<=0:
                            l1.append(l)
                            l2.append(1)
                        else:
                            l2.append(0)
                if a[1]!=l:
                        if a[1]<=0:
                            l1.append(l)
                            l2.append(1)
                        else:
                            l2.append(0)
                #print("l1,l2",l1,l2)
                
                #print("last line->>",a)
        '''if 1 in l2:
                value=min(l1)
                print('possible')
                
                print(value[2],value[1])
        else:
                print('impossible')
                '''
        if len(l1)>0:
            value=min(l1)
            print('possible')
                
            print(value[2],value[1])
        else:
            print('impossible')
except:
    pass