**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
import java.util.*;
import java.lang.*;
import java.io.*;

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		    int c1=0,c2=0;
		    for(int i=1;i<=n;i=i+2)
		    {
		        System.out.println("? "+i+" "+(i+1));
		        int a=sc.nextInt();
		        System.out.println("? "+(i+1)+" "+i);
		        int b=sc.nextInt();
		        if(a!=b){
		            c1=i;c2=i+1;break;
		        }
		    }
		    if(n%2==1){
		          System.out.println("? "+n+" "+1);
		          int a=sc.nextInt();
		          System.out.println("? "+1+" "+n);
		          int b=sc.nextInt();
		          if(a!=b){
		              c1=n;c2=1;
		          }
		    }
		    int g=0;
		    for(int i=1;i<n;i++){
		        if(i!=c1 && i!=c2){
		            g=i;break;
		        }
		    }
		    System.out.println("? "+g+" "+c1);
		    int aa=sc.nextInt();
		    System.out.println("? "+c1+" "+g);
		    int bb=sc.nextInt();
		    if(aa!=bb)
		    {
		        System.out.println("! "+c1);
		    }else System.out.println("! "+c2);

		}
	}
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to consider edge cases and scenarios that maximize the failure probability. The buggy code has several issues, including:

1. It only checks pairs of players in a specific order (i.e., every other player).
2. It does not handle cases where the Impostor is not in the first few pairs it checks.
3. It does not properly handle the case where the Impostor is the last player in the list.

Given these issues, we can create a test case where the Impostor is not in the first few pairs and is placed in a position that is not checked by the code. For example, we can place the Impostor in the middle of the list of players.

Here is a small-scale test input that should expose the bug:

```plaintext
1
7
0
1
0
1
1
0
1
```

Explanation:
- The first line indicates that there is one test case.
- The second line indicates that there are 7 players.
- The subsequent lines represent the responses to the questions asked by the code. The responses are constructed to ensure that the Impostor is not identified correctly by the buggy code.

In this test case:
- Players 1 and 2 are both Knaves.
- Players 3 and 4 are both Knights.
- Player 5 is the Impostor.
- Players 6 and 7 are Knaves.

The responses are crafted to make the code's assumptions fail. For example:
- When the code asks about players 1 and 2, it will get conflicting responses.
- When the code asks about players 3 and 4, it will get consistent responses (both are Knights).
- When the code asks about the Impostor (player 5), it will not be correctly identified because the code does not check all pairs of players.

This test input should reveal the bug in the code's logic.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
import java.util.*;
import java.lang.*;
import java.io.*;

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		while(t-->0)
		{
		    int n=sc.nextInt();
		    int c1=0,c2=0;
		    for(int i=1;i<=n;i=i+2)
		    {
		        System.out.println("? "+i+" "+(i+1));
		        int a=sc.nextInt();
		        System.out.println("? "+(i+1)+" "+i);
		        int b=sc.nextInt();
		        if(a!=b){
		            c1=i;c2=i+1;break;
		        }
		    }
		    if(n%2==1){
		          System.out.println("? "+n+" "+1);
		          int a=sc.nextInt();
		          System.out.println("? "+1+" "+n);
		          int b=sc.nextInt();
		          if(a!=b){
		              c1=n;c2=1;
		          }
		    }
		    int g=0;
		    for(int i=1;i<=n;i++){
		        if(i!=c1 && i!=c2){
		            g=i;break;
		        }
		    }
		    System.out.println("? "+g+" "+c1);
		    int aa=sc.nextInt();
		    System.out.println("? "+c1+" "+g);
		    int bb=sc.nextInt();
		    if(aa!=bb)
		    {
		        System.out.println("! "+c1);
		    }else System.out.println("! "+c2);

		}
	}
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to consider the following:

1. **Edge Cases**: The code might fail when the number of players is small or when the number of players is odd.
2. **Behavior of the Impostor**: The Impostor always lies and is indistinguishable from a Knight to other players.
3. **Consistency of Responses**: The responses must be consistent with the roles of the players.

Given these points, let's create a small-scale test input that can potentially expose the bug:

### Test Input:
```plaintext
1
5
```

### Explanation:
- **Number of Test Cases**: 1
- **Number of Players**: 5

### Roles:
- Let's assign the roles as follows:
  - Player 1: Knight
  - Player 2: Knave
  - Player 3: Impostor
  - Player 4: Knight
  - Player 5: Knave

### Expected Behavior:
- The code will ask questions and try to determine the Impostor.
- The responses should be consistent with the roles:
  - Knight (1) will always tell the truth.
  - Knave (2, 5) will always lie.
  - Impostor (3) will always lie and be indistinguishable from a Knight to other players.

### Expected Questions and Responses:
1. **Query 1**: `? 1 2`
   - Response: 0 (Knight 1 thinks Knave 2 is not a Knight)
2. **Query 2**: `? 2 1`
   - Response: 1 (Knave 2 lies, so they say Player 1 is a Knight)
3. **Query 3**: `? 1 3`
   - Response: 1 (Knight 1 thinks Impostor 3 is a Knight)
4. **Query 4**: `? 3 1`
   - Response: 0 (Impostor 3 lies, so they say Player 1 is not a Knight)
5. **Query 5**: `? 1 4`
   - Response: 1 (Knight 1 thinks Knight 4 is a Knight)
6. **Query 6**: `? 4 1`
   - Response: 1 (Knight 4 thinks Knight 1 is a Knight)
7. **Query 7**: `? 1 5`
   - Response: 0 (Knight 1 thinks Knave 5 is not a Knight)
8. **Query 8**: `? 5 1`
   - Response: 1 (Knave 5 lies, so they say Player 1 is a Knight)
9. **Query 9**: `? 3 4`
   - Response: 0 (Impostor 3 lies, so they say Player 4 is not a Knight)
10. **Query 10**: `? 4 3`
    - Response: 1 (Knight 4 thinks Impostor 3 is a Knight)

### Expected Output:
- The code should determine that Player 3 is the Impostor and output `! 3`.

This test input is designed to challenge the buggy code by ensuring that the responses are consistent with the roles and that the Impostor is correctly identified. The small number of players (5) makes it easier to verify the correctness of the interactions.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define int long long
#define ll long long
#define ld long double
#define pb push_back
#define pf push_front
#define ppb pop_back()
#define ppf pop_front()
#define len(x) (int)x.size()
#define vi vector<int>
#define vpii vector<pair<int,int>>
#define vvi vector<vi>
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define mii map<int,int>
#define y1 SemeyBilimInnovationLyceum
#define tm (tl+tr>>1)
#define ls v<<1,tl,tm
#define rs v<<1|1,tm+1,tr
#define pii pair<int,int>
#define lb lower_bound
#define ub upper_bound
#define f first
#define s second
#define str string
#define ins insert
#define elif else if
using namespace std;
using namespace __gnu_pbds;
template<typename T>using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
const int maxn=5e5+5,mod=1e9+7,inf=1e18,bir=1,nol=0;
const bool TEST=1;
const str DastanulyMagzhan[5]={"NO\n","YES\n","-1\n"};
void at(int ok){cout<<DastanulyMagzhan[ok];}
bool bit(int mask,int i){return ((bir<<i)&mask);}
int gcd(int a,int b){while(b){if(a>b)swap(a,b);b%=a;}return a;}
int lcm(int a,int b){return a/gcd(a,b)*b;}
int bpm(int a,int b){a%=mod;if(b==0)return 1;if(b&1)return bpm(a,b-1)*a%mod;int x=bpm(a,b>>1);return x*x%mod;}
int bp(int a,int b){if(b==0)return 1;if(b&1)return bp(a,b-1)*a;int x=bp(a,b>>1);return x*x;}
int n,a[maxn];
int ask(int i,int j){
	cout<<"? "<<i<<' '<<j<<endl;
	cin>>i;return i;
}
void whyareucopying(){
	cin>>n;
	a[1]=1;
	for(int i=2;i<=n;i++){
		a[i]=a[i-1];
		if(!ask(i-1,i))a[i]^=1;
	}
	int l=1,r=n;
	while(1){
		int md=l+r>>1;
		if(md==1){
			cout<<"! 1"<<endl;return;
		}
		int x=ask(1,md),y=ask(md,1);
		if(x!=y){
			int random=n;
			if(random==md)random--;
			if(ask(random,md)==ask(md,random)){
				cout<<"! 1"<<endl;return;
			}
			cout<<"! "<<md<<endl;return;
		}
		if(a[md]==x)l=md+1;
		else r=md-1;
	}
}
signed main(){
//	freopen("txt.in","r",stdin),freopen("txt.out","w",stdout);
//	ios_base::sync_with_stdio(false),cin.tie(nullptr);
//	srand(time(0));
	int T=1;
	if(TEST)cin>>T;
	for(int i=1;i<=T;i++){
//		cout<<"Case "<<i<<": ";
		whyareucopying();
	}
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to focus on edge cases and scenarios that can cause the algorithm to fail. The key points to consider are:

1. **Small Test Cases**: Since the test input should be small-scale, we can start with the minimum number of players, which is 3.
2. **Edge Cases**: Consider cases where the Impostor is the first, last, or middle player.
3. **Consistent but Misleading Responses**: Ensure that the responses to the questions are consistent with the roles but are designed to mislead the algorithm.

Let's create a test case where the Impostor is the second player, and the responses are consistent but tricky:

```plaintext
1
3
0
1
0
```

### Explanation:
- **Test Case 1**: There is 1 test case.
- **Number of Players**: 3 players.
- **Responses**:
  - When asking player 1 about player 2, the response is "0" (No). This means player 1 is either a Knave or the Impostor, and player 2 is a Knave.
  - When asking player 2 about player 3, the response is "1" (Yes). This means player 2 is either a Knight or the Impostor, and player 3 is a Knight.
  - When asking player 3 about player 1, the response is "0" (No). This means player 3 is a Knight, and player 1 is a Knave or the Impostor.

Given these responses, the algorithm should be able to determine that player 2 is the Impostor. However, if the algorithm has a bug, it might incorrectly identify another player as the Impostor.

This test case is designed to be small and valid, while also being challenging enough to expose potential bugs in the algorithm.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define prs(v) sort(all(v)); v.erase(unique(all(v)), v.end())
using namespace std;
using ll = long long;
using P = pair<ll, ll>;

void solve() {
    int n;
    cin >> n;
    auto Q = [&](int u, int v)-> P {
        int x, y;
        cout << "? " << u << " " << v << endl;
        cin >> x;
        cout << "? " << v << " " << u << endl;
        cin >> y;
        return {x, y};
    };
    if (n == 3) {
        auto [x, y] = Q(1, 2);
        auto [z, a] = Q(2, 3);
        if (x != y) {
            if (z != a)cout << "! 2" << endl;
            else cout << "! 1" << endl;
        } else cout << "! 3" << endl;
        return;
    }
    int i = n - 1;
    if (n & 1) {
        for (int s = 4; s <= n - 2; s += 2) {
            auto [x, y] = Q(s, s + 1);
            if (x != y)i = s;
        }
        int x, y, z, a, b, ans = -1;
        cout << "? 1 2" << endl;
        cin >> x;
        cout << "? 2 3" << endl;
        cin >> y;
        cout << "? 3 1" << endl;
        cin >> z;
        if (x + y + z == 0 || x + y + z == 2) {
            i = 1;
            cout << "? 2 1" << endl;
            cin >> a;
            cout << "? 3 2" << endl;
            cin >> b;
            if (a != x) {
                if (b != y)ans = 2;
                else ans = 1;
            }
            ans = 3;
        }
        int c = (i == 1 ? n : 1);
        if (ans == -1) {
            auto [x, y] = Q(c, i);
            if (x != y)ans = i;
            else ans = i + 1;
            cout << "! " << ans << endl;
        } else cout << "! " << ans << endl;
    } else {
        for (int s = 1; s <= n - 2; s += 2) {
            auto [x, y] = Q(s, s + 1);
            if (x != y)i = s;
        }
        int b = (i == 1 ? n : 1);
        auto [x, y] = Q(b, i);
        int ans = -1;
        if (x != y)ans = i;
        else ans = i + 1;
        cout << "! " << ans << endl;
    }
}

int main() {
    cin.tie(0)->sync_with_stdio(0);
    int T = 1;
    cin >> T;
    while (T--)solve();
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input for the buggy code, we need to focus on edge cases and scenarios that are likely to expose the bugs in the algorithm. Here are the steps to think through this:

1. **Understand the Bug**: The buggy code seems to have issues with how it handles the case when `n` is even or odd, and how it processes the results of the questions.

2. **Edge Cases**:
   - **Small `n`**: Test with the smallest possible value of `n` (3).
   - **Medium `n`**: Test with a medium value of `n` (e.g., 5 or 7).
   - **Large `n`**: Test with a large value of `n` (e.g., 100).

3. **Specific Scenarios**:
   - **Impostor in the first few players**: This can test how the code handles early questions.
   - **Impostor in the last few players**: This can test how the code handles later questions.
   - **Impostor in the middle of the players**: This can test how the code handles a more balanced distribution.

4. **Interactive Responses**:
   - Ensure the responses are consistent with the roles of the players (Knight, Knave, Impostor).

Given these considerations, let's create a test input that is small-scale but complete and valid.

```plaintext
1
7
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
import sys
input = sys.stdin.buffer.readline

def process(n):
    r = [i for i in range(1, n+1)]
    known_equal = []
    known_unequal = []
    imposter_pair = None
    other = []
    while len(r) >= 2:
        x = r.pop()
        y = r.pop()
        sys.stdout.write(f'? {x} {y}\n')
        sys.stdout.flush()
        r1 = int(input())
        sys.stdout.write(f'? {y} {x}\n')
        sys.stdout.flush()
        r2 = int(input())
        if r1==0 and r2==0:
            known_unequal.append([x, y])
            other.append(x)
            other.append(y)
        elif r1==1 and r2==1:
            known_equal.append([x, y])
            other.append(x)
            other.append(y)
        else:
            imposter_pair = [x, y]
    if imposter_pair is None and len(r)==1:
        x = r[0]
        sys.stdout.write(f'! {x}\n')
        sys.stdout.flush()
        return
    z = other[0]
    for x in imposter_pair:
        sys.stdout.write(f'? {x} {z}\n')
        sys.stdout.flush()
        r1 = int(input())
        sys.stdout.write(f'? {z} {x}\n')
        sys.stdout.flush()
        r2 = int(input())
        if r1 != r2:
            sys.stdout.write(f'! {x}\n')
            sys.stdout.flush()
            return

t = int(input())
for i in range(t):
    n = int(input())
    process(n)

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
```plaintext
1
3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
for _ in range(int(input())):
    n = int(input())

    sus = [x+1 for x in range(n%3)]
    for i in range(n%3,n,3):
        a = 0
        print("?",i+3,i+1)
        a += int(input())
        print("?",i+2,i+1)
        a += int(input())
        print("?",i+2,i+3)
        a += int(input())
        if a == 2 or a == 0:
            sus = [i+1,i+2,i+3]
            break
    while len(sus) < 3:
        for x in range(1,n):
            if x not in sus:
                sus.append(x)
                break

    print("?",sus[0],sus[1])
    a12 = int(input())
    print("?",sus[1],sus[0])
    a21 = int(input())
    print("?",sus[0],sus[2])
    a13 = int(input())
    print("?",sus[2],sus[0])
    a31 = int(input())
    print("?",sus[1],sus[2])
    a23 = int(input())
    print("?",sus[2],sus[1])
    a32 = int(input())

    if (a12 != a21 and a23 != a32):
        print("!", sus[1])
        continue
    elif (a12 != a21 and a13 != a31):
        print("!", sus[0])
        continue
    elif a23 != a32 and a13 != a31:
        print("!",sus[2])
        continue

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given code, we need to consider edge cases and scenarios where the code might fail. The code provided has a specific approach to identify the Impostor by asking a series of questions and analyzing the responses. The main issues in the code are:

1. The code assumes that the roles of players are fixed in the beginning, but the grader is adaptive, meaning roles can change based on the questions asked.
2. The code does not handle the adaptive nature of the grader effectively, which can lead to incorrect assumptions about the roles of players.

Given these points, we can create a test case that:

1. Has a small number of players to keep the input manageable.
2. Forces the code to make incorrect assumptions about the roles of players, leading to an incorrect identification of the Impostor.

Let's consider a test case with 4 players. We will set up the roles in such a way that the code's assumptions are likely to be incorrect.

### Test Case:
- Player 1: Knight
- Player 2: Knave
- Player 3: Impostor
- Player 4: Knight

### Expected Interaction:
- The code will ask questions and try to identify the Impostor.
- We will provide responses that are consistent with the roles of the players but also try to mislead the code.

### Test Input:
```plaintext
1
4
0
1
1
1
```

### Explanation:
- The first line indicates that there is one test case.
- The second line indicates that there are 4 players.
- The next four lines are the responses to the questions asked by the code.

### Expected Behavior:
- The code will ask questions to determine the roles of the players.
- The responses provided will be consistent with the roles:
  - Player 1 (Knight) will always tell the truth.
  - Player 2 (Knave) will always lie.
  - Player 3 (Impostor) will always lie.
  - Player 4 (Knight) will always tell the truth.

### Possible Questions and Responses:
1. `? 4 1` -> 1 (Player 4 is a Knight and Player 1 is a Knight, so the answer is "yes")
2. `? 3 1` -> 1 (Player 3 is an Impostor and Player 1 is a Knight, so the answer is "yes" because the Impostor lies)
3. `? 3 4` -> 0 (Player 3 is an Impostor and Player 4 is a Knight, so the answer is "no" because the Impostor lies)
4. `? 2 1` -> 0 (Player 2 is a Knave and Player 1 is a Knight, so the answer is "no" because the Knave lies)
5. `? 1 2` -> 0 (Player 1 is a Knight and Player 2 is a Knave, so the answer is "no" because the Knight tells the truth)
6. `? 1 3` -> 1 (Player 1 is a Knight and Player 3 is an Impostor, so the answer is "yes" because the Knight tells the truth)
7. `? 3 1` -> 1 (Player 3 is an Impostor and Player 1 is a Knight, so the answer is "yes" because the Impostor lies)
8. `? 2 3` -> 0 (Player 2 is a Knave and Player 3 is an Impostor, so the answer is "no" because the Knave lies)
9. `? 3 2` -> 1 (Player 3 is an Impostor and Player 2 is a Knave, so the answer is "yes" because the Impostor lies)
10. `? 4 3` -> 0 (Player 4 is a Knight and Player 3 is an Impostor, so the answer is "no" because the Knight tells the truth)

### Final Output:
```plaintext
1
4
0
1
1
1
```

This test input should expose the bug in the code by leading it to make incorrect assumptions about the roles of the players.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
import java.io.*;
import java.util.*;

public class probd {
    public static void main(String[] args) throws InterruptedException {
        //FastReader r = new FastReader();
        PrintWriter w = new PrintWriter(System.out);
        Scanner s = new Scanner(System.in);

        int t = s.nextInt();
        while (t-->0) {
            int n = s.nextInt();

            int sol = solution(n, s, w);
            System.out.println("! " + sol);
        }
        s.close();
        w.close();
    }

    public static int solution(int n, Scanner s, PrintWriter w) throws InterruptedException {
        //HashMap<Tuple, Boolean> cache = new HashMap<>();
        //int l = 1;
        //int r = n+1;
        ////l and right could be imposter
        ////right of r cannot be imposter
        //while (l+1 < r) {
        //    int mid = (l+r)/2; //include mid in left half
        //    if (inLeftHalf(l, mid, s, w, cache)) {
        //        r = mid;
        //    }
        //    else {
        //        l = mid+1;
        //    }
        //    //System.err.println("l, r is " + l + " , " + r);
        //}
        ////System.err.println("l, r is " + l + " , " + r);

        //int checker = 1;
        //if (l == 1) checker = n;

        //if (ask(checker, l, s, w, cache) != ask(l, checker, s, w, cache)) return l;
        //else return r;

        for (int i = 1; i < n; i+=2) {
            if (ask(i, i+1, s) != ask(i+1, i, s)) {
                int check = 1;
                if (i == 1) check = n;
                if (ask(i, check, s) != ask(check, i, s)) return i;
                else return i+1;
            }
        }

        s.close();
        return n;
    }

//    public static boolean inLeftHalf(int l, int mid, Scanner s, PrintWriter w, HashMap<Tuple, Boolean> cache) throws Exception {
//        int bads = 0;
//        for (int i = l; i < mid; i++) {
//            bads+=ask(i, i+1, s, w, cache) ? 0 : 1;
//        }
//        bads+=ask(mid, l, s, w, cache) ? 0 : 1;
//
//        return bads % 2 == 1;
//    }
//
    public static boolean ask(int i, int j, Scanner s) throws InterruptedException {
        //Tuple t = new Tuple(i, j);
        //if (cache.containsKey(t)) return cache.get(t);
        System.out.println(String.format("? %d %d", i, j));

        //w.flush();
        int ans = s.nextInt();
        if (ans == -1) {
            Thread.sleep(2000);
            System.exit(1);
        }
        //cache.put(t, ans == 1);
        return ans== 1;
    }

    static class Tuple implements Comparable<Tuple>{
        int a;
        int b;

        public Tuple(int a, int b) {
            this.a=a;
            this.b=b;
        }

        public int compareTo(Tuple t) {
            if (this.a < t.a) return -1;
            if (this.a > t.a) return 1;

            if (this.b < t.b) return -1;
            if (this.b > t.b) return 1;

            return 0;
        }

        @Override
        public int hashCode() {
            return a<<16 + b;
        }

        @Override
        public boolean equals(Object t) {
            Tuple tup = (Tuple)t;
            return a == tup.a && b == tup.b;
        }
    }

    static class FastReader implements AutoCloseable {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }
        public FastReader(String filepath) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(filepath));
        }

        public void close() throws IOException {
            br.close();
        }

        /** Indicates whether or not more input is available
         * @Warning BUGGY
         */
        boolean hasNext() throws IOException {
            return (br.ready());
        }

        /** Returns the next char available
         * @warning
         * CAREFUL, BUGGY
         * @return the next available char
         */

        char nextChar() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer("" + (char)br.read());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            return st.nextToken().charAt(0);
        }

        /**
         * Gives the entire next element (terminates in a whitespace)
         * @return the next full 'word'
         */
        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            String str = "";
            try {
                if(st.hasMoreTokens()){
                    str = st.nextToken("\n");
                }
                else{
                    str = br.readLine();
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        /**
         * Returns an array of longs read from input
         * @param n - the number of longs to read
         * @return an array of length n containing the longs that were read
         */
        long[] longArray(int n) {
            long[] a = new long[n];
            for (int i = 0;i < n;i++) {
                a[i] = this.nextLong();
            }

            return a;
        }
        /**
         * Returns an array of ints read from input
         * @param n - the number of ints to read
         * @return an array of length n containing the ints that were read
         */
        int[] intArray(int n) {
            int[] a = new int[n];
            for (int i = 0;i < n;i++) {
                a[i] = this.nextInt();
            }

            return a;
        }

        /**
         * Returns a freqeuency array based on the number of appearance of each int that is read
         * @param n - the number of ints to read
         * @param largestNum - the largest number that may appear
         * @return an array of length largestNum that contains the appearance frequency of each value
         */
        int[] counts(int n, int largestNum) {
            int[] counts = new int[largestNum+1];
            for (int i = 0; i < n; i++) {
                counts[this.nextInt()]++;
            }

            return counts;
        }

        /**
         * Returns the boolean array represented by the next input line and a given char
         * @param t - the char that represents 'true'
         * @return an array representing the next line's truth values
         */
        boolean[] boolLine(char t) {
            String line = this.nextLine();
            boolean[] res = new boolean[line.length()];
            for (int i = 0; i < line.length(); i++) {
                res[i] = line.charAt(i) == t ? true : false;
            }

            return res;
        }

        /**
         * Returns a 2D array that contains the truth values specified by t according to the input read
         * @param rows - the number of rows to read
         * @param cols - the number of cols in each row
         * @param t - the char that represents 'true'
         * @return a 2D array representing the next lines' truth values
         */
        boolean[][] boolRect(int rows, int cols, char t) {
            boolean[][] res = new boolean[rows][cols];
            for (int i = 0;i < rows;i++) {
                String line = this.nextLine().strip();
                if (line.length() != cols) throw new RuntimeException("Number of cols was incorrect");
                for (int j = 0; j < cols; j++) {
                    res[i][j] = line.charAt(j) == t ? true : false;
                }
            }

            return res;
        }

        /**
         * Like a rectangle, but it's a square
         * @param n - side length
         * @param t - the char that represents 'true'
         * @return - a 2D array representing the next lines' truth values
         */
        boolean[][] boolSquare(int n, char t) {
            return boolRect(n,n,t);
        }
    }

}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to focus on edge cases and scenarios that can cause the code to fail. The buggy code uses a simple approach to find the Impostor by comparing pairs of players. It assumes that if two players have different responses when asked about each other, one of them must be the Impostor. However, this approach can fail in certain configurations.

### Step-by-Step Analysis:
1. **Understanding the Bug:**
   - The code compares pairs of players and checks if their responses are different.
   - If the responses are different, it assumes one of them is the Impostor.
   - This approach can fail if there are multiple Knaves or Knights that create conflicting responses.

2. **Edge Cases to Consider:**
   - **Small Number of Players:** The code might fail with a small number of players, especially when the number of Knaves and Knights is not balanced.
   - **Symmetric Responses:** If all players have symmetric responses (i.e., they all agree with each other), the code might not be able to identify the Impostor.
   - **Mixed Responses:** A mix of Knaves and Knights can create confusing responses that might not be correctly interpreted by the code.

3. **Constructing the Test Input:**
   - **Number of Players:** Choose a small number of players, such as 4 or 5, to make the test input manageable and to ensure that the code's logic is thoroughly tested.
   - **Player Roles:** Assign roles such that the responses create a challenging scenario for the code. For example, having two Knaves and two Knights can create mixed responses.

### Challenging Test Input:
Let's consider a test case with 4 players where the roles are as follows:
- Player 1: Knight
- Player 2: Knight
- Player 3: Knave
- Player 4: Impostor

This configuration will create mixed responses that can challenge the code's logic.

### Test Input:
```plaintext
1
4
```

### Explanation:
- **Player 1 (Knight) vs Player 2 (Knight):**
  - Player 1 will say Player 2 is a Knight.
  - Player 2 will say Player 1 is a Knight.
- **Player 1 (Knight) vs Player 3 (Knave):**
  - Player 1 will say Player 3 is a Knave.
  - Player 3 will say Player 1 is a Knave (lying).
- **Player 1 (Knight) vs Player 4 (Impostor):**
  - Player 1 will say Player 4 is a Knight.
  - Player 4 will say Player 1 is a Knave (lying).
- **Player 2 (Knight) vs Player 3 (Knave):**
  - Player 2 will say Player 3 is a Knave.
  - Player 3 will say Player 2 is a Knave (lying).
- **Player 2 (Knight) vs Player 4 (Impostor):**
  - Player 2 will say Player 4 is a Knight.
  - Player 4 will say Player 2 is a Knave (lying).
- **Player 3 (Knave) vs Player 4 (Impostor):**
  - Player 3 will say Player 4 is a Knight (lying).
  - Player 4 will say Player 3 is a Knave (lying).

This setup will create a mix of responses that can challenge the code's logic, especially when it tries to determine the Impostor based on the differences in responses.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
import java.io.*;
import java.util.*;

public class probd {
    public static void main(String[] args) throws Exception {
        //FastReader r = new FastReader();
        PrintWriter w = new PrintWriter(System.out);
        Scanner s = new Scanner(System.in);

        int t = s.nextInt();
        while (t-->0) {
            int n = s.nextInt();

            int sol = solution(n, s, w);
            w.write("! " + sol +"\n");
            w.flush();
        }
        s.close();
        w.close();
    }

    public static int solution(int n, Scanner s, PrintWriter w) throws Exception {
        //HashMap<Tuple, Boolean> cache = new HashMap<>();
        //int l = 1;
        //int r = n+1;
        ////l and right could be imposter
        ////right of r cannot be imposter
        //while (l+1 < r) {
        //    int mid = (l+r)/2; //include mid in left half
        //    if (inLeftHalf(l, mid, s, w, cache)) {
        //        r = mid;
        //    }
        //    else {
        //        l = mid+1;
        //    }
        //    //System.err.println("l, r is " + l + " , " + r);
        //}
        ////System.err.println("l, r is " + l + " , " + r);

        //int checker = 1;
        //if (l == 1) checker = n;

        //if (ask(checker, l, s, w, cache) != ask(l, checker, s, w, cache)) return l;
        //else return r;

        for (int i = 1; i < n; i+=2) {
            if (ask(i, i+1, s) != ask(i+1, i, s)) {
                int check = 1;
                if (i == 1) check = n;
                if (ask(i, check, s) != ask(check, i, s)) return i;
                else return i+1;
            }
        }

        s.close();
        return n;
    }

//    public static boolean inLeftHalf(int l, int mid, Scanner s, PrintWriter w, HashMap<Tuple, Boolean> cache) throws Exception {
//        int bads = 0;
//        for (int i = l; i < mid; i++) {
//            bads+=ask(i, i+1, s, w, cache) ? 0 : 1;
//        }
//        bads+=ask(mid, l, s, w, cache) ? 0 : 1;
//
//        return bads % 2 == 1;
//    }
//
    public static boolean ask(int i, int j, Scanner s) throws Exception {
        //Tuple t = new Tuple(i, j);
        //if (cache.containsKey(t)) return cache.get(t);
        System.out.print(String.format("? %d %d\n", i, j));
        System.out.flush();

        //w.flush();
        int ans = s.nextInt();
        if (ans == -1) System.exit(1);
        //cache.put(t, ans == 1);
        return ans== 1;
    }

    static class Tuple implements Comparable<Tuple>{
        int a;
        int b;

        public Tuple(int a, int b) {
            this.a=a;
            this.b=b;
        }

        public int compareTo(Tuple t) {
            if (this.a < t.a) return -1;
            if (this.a > t.a) return 1;

            if (this.b < t.b) return -1;
            if (this.b > t.b) return 1;

            return 0;
        }

        @Override
        public int hashCode() {
            return a<<16 + b;
        }

        @Override
        public boolean equals(Object t) {
            Tuple tup = (Tuple)t;
            return a == tup.a && b == tup.b;
        }
    }

    static class FastReader implements AutoCloseable {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }
        public FastReader(String filepath) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(filepath));
        }

        public void close() throws IOException {
            br.close();
        }

        /** Indicates whether or not more input is available
         * @Warning BUGGY
         */
        boolean hasNext() throws IOException {
            return (br.ready());
        }

        /** Returns the next char available
         * @warning
         * CAREFUL, BUGGY
         * @return the next available char
         */

        char nextChar() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer("" + (char)br.read());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            return st.nextToken().charAt(0);
        }

        /**
         * Gives the entire next element (terminates in a whitespace)
         * @return the next full 'word'
         */
        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            String str = "";
            try {
                if(st.hasMoreTokens()){
                    str = st.nextToken("\n");
                }
                else{
                    str = br.readLine();
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        /**
         * Returns an array of longs read from input
         * @param n - the number of longs to read
         * @return an array of length n containing the longs that were read
         */
        long[] longArray(int n) {
            long[] a = new long[n];
            for (int i = 0;i < n;i++) {
                a[i] = this.nextLong();
            }

            return a;
        }
        /**
         * Returns an array of ints read from input
         * @param n - the number of ints to read
         * @return an array of length n containing the ints that were read
         */
        int[] intArray(int n) {
            int[] a = new int[n];
            for (int i = 0;i < n;i++) {
                a[i] = this.nextInt();
            }

            return a;
        }

        /**
         * Returns a freqeuency array based on the number of appearance of each int that is read
         * @param n - the number of ints to read
         * @param largestNum - the largest number that may appear
         * @return an array of length largestNum that contains the appearance frequency of each value
         */
        int[] counts(int n, int largestNum) {
            int[] counts = new int[largestNum+1];
            for (int i = 0; i < n; i++) {
                counts[this.nextInt()]++;
            }

            return counts;
        }

        /**
         * Returns the boolean array represented by the next input line and a given char
         * @param t - the char that represents 'true'
         * @return an array representing the next line's truth values
         */
        boolean[] boolLine(char t) {
            String line = this.nextLine();
            boolean[] res = new boolean[line.length()];
            for (int i = 0; i < line.length(); i++) {
                res[i] = line.charAt(i) == t ? true : false;
            }

            return res;
        }

        /**
         * Returns a 2D array that contains the truth values specified by t according to the input read
         * @param rows - the number of rows to read
         * @param cols - the number of cols in each row
         * @param t - the char that represents 'true'
         * @return a 2D array representing the next lines' truth values
         */
        boolean[][] boolRect(int rows, int cols, char t) {
            boolean[][] res = new boolean[rows][cols];
            for (int i = 0;i < rows;i++) {
                String line = this.nextLine().strip();
                if (line.length() != cols) throw new RuntimeException("Number of cols was incorrect");
                for (int j = 0; j < cols; j++) {
                    res[i][j] = line.charAt(j) == t ? true : false;
                }
            }

            return res;
        }

        /**
         * Like a rectangle, but it's a square
         * @param n - side length
         * @param t - the char that represents 'true'
         * @return - a 2D array representing the next lines' truth values
         */
        boolean[][] boolSquare(int n, char t) {
            return boolRect(n,n,t);
        }
    }

}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To expose the bug in the provided code, we need to focus on scenarios that can cause the algorithm to fail. The key points to consider are:

1. **Edge Cases**: Small values of `n` where the behavior of the algorithm can be more predictable and easier to analyze.
2. **Balanced Distribution**: A scenario where the distribution of Knights, Knaves, and the Impostor is balanced to ensure that the algorithm's assumptions are tested thoroughly.
3. **Adaptive Nature**: The grader is adaptive, so the roles of players can change based on the questions asked. This means we need to create a scenario that challenges the algorithm's ability to adapt.

Given these considerations, let's create a small-scale test input:

```plaintext
2
3
1
0
0
1
4
0
1
1
1
```

### Explanation:

1. **First Test Case (n = 3)**:
   - Player 1: Knave
   - Player 2: Knight
   - Player 3: Impostor

   - Questions and Expected Answers:
     - `? 1 2` -> 0 (Knave lies)
     - `? 2 3` -> 1 (Knight tells the truth)
     - `? 3 1` -> 0 (Impostor lies)

   - The algorithm should be able to identify Player 3 as the Impostor.

2. **Second Test Case (n = 4)**:
   - Player 1: Knight
   - Player 2: Knave
   - Player 3: Knight
   - Player 4: Impostor

   - Questions and Expected Answers:
     - `? 1 2` -> 0 (Knight tells the truth)
     - `? 2 3` -> 1 (Knave lies)
     - `? 3 4` -> 1 (Knight tells the truth)
     - `? 4 1` -> 0 (Impostor lies)

   - The algorithm should be able to identify Player 4 as the Impostor.

This test input is designed to cover both a small and a slightly larger case, ensuring that the algorithm is tested for its ability to handle different scenarios and to adapt to the changing roles of the players.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
#include <bits/stdc++.h>
const int N = 1e5 + 5;
int n, res[N];
bool Ask(int i, int j) {
	if (i == 1 && j == 1) {
		return Ask(3, j) ^ res[3];
	}
	printf("? %d %d\n", i, j), fflush(stdout);
	int ret;
	scanf("%d", &ret);
	return !ret;
}

int main() {
	int T;
	scanf("%d", &T);
	while (T--) {
		scanf("%d", &n);
		for (int i = 2; i <= n; i++) res[i] = res[i - 1] ^ Ask(i, i - 1);
		// for (int i = 1; i <= n; i++) printf("%d ", res[i]);
		// puts("");
		int l = 1, r = n;
		while (l < r) {
			int mid = (l + r) >> 1;
			// if (mid == 1) { l = 1; break; }
			if (Ask(1, mid) != res[mid]) r = mid;
			else l = mid + 1;
		}
		printf("! %d\n", l), fflush(stdout);
	}
	return 0;
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To expose the bug in the given code, we need to focus on the logic of the `Ask` function and the main loop that determines the Impostor. The bug in the code is related to how the `Ask` function handles the special case when `i == 1` and `j == 1`. This special case is incorrect because it tries to call `Ask(3, j)`, which is not a valid question since `j` is already 1. This can lead to an infinite loop or incorrect behavior.

To create a test input that exposes this bug, we need a small-scale test case where the first player (player 1) is involved in a question that triggers this special case. Here's a small-scale test input that should expose the bug:

```plaintext
1
3
0
1
0
```

Explanation:
- The first line `1` indicates there is one test case.
- The second line `3` indicates there are 3 players.
- The following lines `0`, `1`, and `0` represent the answers to the questions asked by the program.

In this test case:
- Player 1 is a Knave.
- Player 2 is a Knight.
- Player 3 is the Impostor.

The program will ask questions and eventually trigger the special case in the `Ask` function when `i == 1` and `j == 1`. This should expose the bug in the code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Asesino (Easy Version)
time_limit_ms: 2500
memory_limit_mb: 256
Description: This is the easy version of the problem. In this version, you can ask at most $$$n+69$$$ questions. You can make hacks only if both versions of the problem are solved.

This is an interactive problem.

It is a tradition in Mexico's national IOI trainings to play the game "Asesino", which is similar to "Among Us" or "Mafia".

Today, $$$n$$$ players, numbered from $$$1$$$ to $$$n$$$, will play "Asesino" with the following three roles:

- Knight: a Knight is someone who always tells the truth.
- Knave: a Knave is someone who always lies.
- Impostor: an Impostor is someone everybody thinks is a Knight, but is secretly a Knave.

Each player will be assigned a role in the game. There will be exactly one Impostor but there can be any (possible zero) number of Knights and Knaves.

As the game moderator, you have accidentally forgotten the roles of everyone, but you need to determine the player who is the Impostor.

To determine the Impostor, you will ask some questions. In each question, you will pick two players $$$i$$$ and $$$j$$$ ($$$1 \leq i, j \leq n$$$; $$$i \neq j$$$) and ask if player $$$i$$$ thinks that player $$$j$$$ is a Knight. The results of the question is shown in the table below.

KnightKnaveImpostorKnightYesNoYesKnaveNoYesNoImpostorNoYes— The response of the cell in row $$$a$$$ and column $$$b$$$ is the result of asking a question when $$$i$$$ has role $$$a$$$ and $$$j$$$ has row $$$b$$$. For example, the "Yes" in the top right cell belongs to row "Knight" and column "Impostor", so it is the response when $$$i$$$ is a Knight and $$$j$$$ is an Impostor.

Find the Impostor in at most $$$n + 69$$$ questions.

Note: the grader is adaptive: the roles of the players are not fixed in the beginning and may change depending on your questions. However, it is guaranteed that there exists an assignment of roles that is consistent with all previously asked questions under the constraints of this problem.

Input: The first line of input contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $$$n$$$ ($$$3 \le n \le 10^5$$$) — the number of people playing the game.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

Output: None

Examples:
input:
2
7

1

0

0

1

1

0

0

1

4

0

1

1

1
output:
? 1 3

? 7 6

? 2 5

? 6 2

? 4 5

? 4 6

? 1 4

? 2 4

! 4

? 1 2

? 2 3

? 3 4

? 4 1

! 3

Note: Note that the example test cases do not represent an optimal strategy for asking questions and are only shown for the sake of demonstrating the interaction format. Specifically, we cannot determine which player is the Impostor from the questions asked in the examples.

In the first test case of the example, players at indices $$$2$$$ and $$$6$$$ are Knights, players at indices $$$1$$$, $$$3$$$, $$$5$$$, and $$$7$$$ are Knaves, and the Impostor is at index $$$4$$$. The following is an explanation of the questions asked:

- In the first query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knave. The answer is "yes" since Knaves always lie.
- In the second query, player $$$i$$$ is a Knave and player $$$j$$$ is a Knight. The answer is "no" since Knaves always lie.
- In the third query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knave. The answer is "no" since Knights always tell the truth.
- In the fourth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Knight. The answer is "yes" since Knights always tell the truth.
- In the fifth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knave. The answer is "yes" since the Impostor always lies.
- In the sixth query, player $$$i$$$ is a Impostor and player $$$j$$$ is a Knight. The answer is "no" since the Impostor always lies.
- In the seventh query, player $$$i$$$ is a Knave and player $$$j$$$ is a Impostor. The answer is "no" since Knaves always lie and Knaves thinks that the Impostor is a Knight.
- In the eighth query, player $$$i$$$ is a Knight and player $$$j$$$ is a Impostor. The answer is "yes" since Knights always tell the truth and Knights think that the Impostor is a Knight.

Buggy Code:
#include <bits/extc++.h>
#include <bits/stdc++.h>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
const int maxn=1e5+5;
int G[2*maxn],n,p[2*maxn];

int q(int i,int j)
{
	int ans;
	cout<<"? "<<i<<' '<<j<<endl;
	cin>>ans;
	return ans;
}
bool judge(int d)
{
	int now=q(d,1);
	if(now==p[d])
		return false;
	else
		return true;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t;
    cin>>t;
    while (t--)
    {
		cin>>n;
		p[1]=1;
		p[1+n]=0;
		for(int i=1;i<n;i++)
		{
			if(q(i,i+1))
			{
				G[i]=i+1;
				G[i+n]=i+1+n;
				p[i+1]=p[i];
				p[i+1+n]=p[i+n];
			}
			else
			{
				G[i]=i+1+n;
				p[i+1+n]=p[i];
				G[i+n]=i+1;
				p[i+1]=p[i+n];
			}
		}
		int tmp=q(n,2);
		if(tmp)
		{
			if(p[n]==p[2])
			{
				cout<<"! 1"<<endl;
				continue;
			}
		}
		else
		{
			if(tmp!=p[2])
			{
				cout<<"! 1"<<endl;
				continue;
			}
		}
		int l=2,r=n,ans=-1;
		while (l<=r)
		{
			int mid=l+r>>1;
			if(judge(mid))
			{
				ans=mid;
				r=mid-1;
			}
			else
				l=mid+1;
		}
		cout<<"! "<<ans<<endl;
    }
}

**Instructions:**
- Focus on edge cases or scenarios that maximize the failure probability in faulty solutions.
- Due to the output length limit, you should generate a **small-scale** test input that is **complete and valid**.
- Output the test input directly, not code to generate it.

**Output format:**
```plaintext
{test input}
```

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to focus on edge cases and scenarios that maximize the failure probability. The code has several potential issues, including incorrect handling of the binary search and the initial setup of the `p` array. Let's break down the problem and identify a test case that can expose these issues.

### Step-by-Step Analysis

1. **Initial Setup and Edge Cases:**
   - The code initializes `p[1] = 1` and `p[1+n] = 0`. This might cause issues if the first player is the Impostor.
   - The binary search logic in the `judge` function and the main loop might not handle the Impostor correctly.

2. **Binary Search and Impostor Detection:**
   - The binary search in the code is supposed to find the Impostor, but it might fail if the initial conditions are not set correctly.
   - The `judge` function checks if the response from player `d` to player `1` is consistent with the `p` array. This might fail if the Impostor is not correctly identified.

3. **Test Case Generation:**
   - We need a small-scale test case with a specific arrangement of roles that can expose the issues in the code.
   - Let's consider a test case with 4 players, where the Impostor is player 2, and the other players are either Knights or Knaves.

### Challenging Test Case

Let's create a test case where:
- Player 1 is a Knight.
- Player 2 is the Impostor.
- Player 3 is a Knave.
- Player 4 is a Knight.

This setup should be challenging because:
- The code might incorrectly assume that player 1 is the Impostor if it doesn't handle the initial conditions correctly.
- The binary search might not correctly identify player 2 as the Impostor.

### Test Input

```plaintext
1
4
0
1
1
1
```

### Explanation

- The first line `1` indicates that there is one test case.
- The second line `4` indicates that there are 4 players.
- The next lines represent the responses to the questions:
  - `? 1 2` (Player 1 thinks Player 2 is a Knight): `0` (No, because Player 1 is a Knight and Player 2 is the Impostor).
  - `? 2 3` (Player 2 thinks Player 3 is a Knight): `1` (Yes, because Player 2 is the Impostor and lies).
  - `? 3 4` (Player 3 thinks Player 4 is a Knight): `1` (Yes, because Player 3 is a Knave and lies).
  - `? 4 1` (Player 4 thinks Player 1 is a Knight): `1` (Yes, because Player 4 is a Knight and tells the truth).

This test case should expose the bug in the code, as the Impostor is player 2, and the code might not correctly identify this due to the issues in the initial setup and the binary search logic.