**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
def qu(l,x):
    if (l,x) not in D:
        print("?",l+1,x)
        D[(l,x)] = int(input()) - 1
    return D[(l,x)]

for _ in range(int(input())):
    D = dict()
    n,k = map(int,input().split())
    mx = -1
    for i in range(1,n+1):
        kk = qu(0,i*n)
        if kk == n - 1:
            mx = i
            break
    longest = n - k + 1
    shortest = 1
    sol = -1
    if k == 1: shortest = longest
    for j in range(shortest,longest+1):
        kk = qu(0,j*mx)
        if kk != n:
            tot = j * mx * k
            rest = tot - j * mx
            last = kk + 1
            for c in range(1,k):
                left = k - c
                if n - last < left or rest > left * j * mx:
                    break
                kk = qu(last,j*mx)
                if kk != n:
                    rest -= j * mx
                    last = kk + 1
                else:
                    break
            else:
                if last == n:
                    sol = j * mx
    print("!", sol)
    haha = int(input())
    if haha == -1:
        exit()

**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
5 2
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
//make sure to make new file!
import java.io.*;
import java.util.*;

public class D945{

   public static BufferedReader f;
   public static PrintWriter out;

   public static void main(String[] args)throws IOException{
      f = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);

      int t = Integer.parseInt(f.readLine());

      for(int q = 1; q <= t; q++){

         StringTokenizer st = new StringTokenizer(f.readLine());

         int n = Integer.parseInt(st.nextToken());
         int m = Integer.parseInt(st.nextToken());

         //get maximum value in the array
         int max = -1;
         for(int k = n; k >= 1; k--){
            int ret = query(1,n*k);
            if(ret == n){
               max = k;
               break;
            }
         }

         int answer = -1;
         //upper bound on answer is floor(n/m) * max
         for(int k = n/m; k >= 1; k--){
            int i = 0;
            for(int j = 0; j < m; j++){
               i = query(i+1,k*max);
               if(i == n+1) break;
            }

            if(i == n){
               answer = k*max;
               break;
            }
         }

         out.println("! " + answer);
         out.flush();

         int one = Integer.parseInt(f.readLine());

      }

      out.close();
   }

   public static int query(int l, int x) throws IOException{
      out.println("? " + l + " " + x);
      out.flush();

      return Integer.parseInt(f.readLine());
   }

}

**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, let's consider the following points:

1. **Edge Cases**:
   - The array is of length 1.
   - The array has all elements the same.
   - The array has elements that are not uniformly distributed.
   - The array has a large maximum value at a specific position.
   - The value of \( k \) is 1.
   - The value of \( k \) is equal to \( n \).

2. **Buggy Code Analysis**:
   - The code attempts to find the maximum value in the array by querying from 1 to \( n \times k \).
   - It then tries to find a valid split by iterating over possible values of \( k \) and checking if the subarrays meet the criteria.

3. **Challenging Input**:
   - An array with a large maximum value at a specific position can make the code's assumption about the maximum value incorrect.
   - An array with a non-uniform distribution of values can make the code's splitting logic fail.

Given these considerations, let's create a test input that is small-scale but challenging:

```plaintext
1
5 2
1 3 5 2 4
```

### Explanation:
- **Test Case**: 1
- **Array Length (n)**: 5
- **Number of Subarrays (k)**: 2
- **Array**: [1, 3, 5, 2, 4]

### Why This Input is Challenging:
- The array has a maximum value of 5, which is not at the beginning or end of the array.
- The values are not uniformly distributed, which can challenge the code's logic for finding the maximum and splitting the array.
- The value of \( k \) is 2, which means the array needs to be split into two subarrays with equal \( f(l, r) \) values. This can expose issues in the code's splitting logic.

This input should help expose the bug in the provided buggy code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

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

/*
    14-06-2024 12:10
*/

public class D {
    /*-----------------------your solution goes here----------------------*/

    static boolean solve() throws IOException {
        int n = ni(),k = ni();
//        pl(" "+n+" "+k);
        int max = -1;
        for(int i = n;i>0;i--){
            pl("? 1 "+i*n);
            out.flush();
            if(ni()==n)max =i;
            if(max!=-1)break;
        }
//        pl("s"+max);
        for (int i = 1; i <=n; i++) {
            if(k*i>n)break;
            if(help(max*i,k,n,i)){
                pl("! "+(max*i));
                out.flush();
                return ni()==-1;
            }
        }
        pl("! -1");
        out.flush();
        return ni()==-1;
    }

    static boolean help(int max,int k,int n,int mul) throws IOException {
        int prev = 1;
        for (int i = k;i>0;i--) {
            if(i*mul>n)break;
            pl("? "+prev+" "+max);
            out.flush();
            prev = ni();
            if(prev>=n ){
                return prev==n;
            }
            prev++;
        }
        return false;
    }

    /*-------------------------------Main Method-----------------------------*/

    public static void main(String[] args) throws IOException {
        long startTime = System.nanoTime();
        long initialMemoryUsed = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        boolean localFileReader = fileReader();
        int testcase = ni();
        while (testcase-- > 0) {
            if(solve()){
                break;
            }
        }

        if (localFileReader) {
            timeAndMemoryDetails(startTime, initialMemoryUsed);
        }
        close();
    }

    /*----------------------------Time and Memory------------------------------*/

    static void timeAndMemoryDetails(long startTime, long initialMemory) {
        final long MEGABYTE = 1024L * 1024L;
        final long millisecond = 1000_000L;
        long afterUsedMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        p("--------------------------\nExecution Time :");
        p((System.nanoTime() - startTime) / millisecond);
        p("ms \nMemory used    :");
        p((afterUsedMem - initialMemory) / MEGABYTE);
        pl("MB");
    }

    /*------------------------------Variables -----------------------------*/
    final static int imax = Integer.MAX_VALUE;
    final static int i_min = Integer.MIN_VALUE;
    final static long lmax = Long.MAX_VALUE;
    final static long l_min = Long.MIN_VALUE;
    final static int mod = 1000_000_007;
    final static int maxArraySize = 2_000_001;
    static long[] fact;

    /*--------------------------------------FastIO Class-------------------*/
    static final private int BUFFER_SIZE = 1 << 16;
    static private DataInputStream din = new DataInputStream(System.in);
    static private final byte[] buffer = new byte[BUFFER_SIZE];
    static private int bufferPointer, bytesRead;

    /*-----------------local file reader ---------------------------------------*/
    public static boolean fileReader() throws IOException {
        String File = "someFile";
        try {
            File = System.getProperty("user.dir");
        } catch (Exception ignored) {
        }
        if (new File(File).getName().equals("CP")) {
            din = new DataInputStream(new FileInputStream("src/Input.txt"));
            out = new PrintWriter(new FileOutputStream("src/Output.txt"));
            return true;
        }
        return false;
    }

    /*-----------------------input methods-----------------------------------------*/
    static String next() throws IOException {
        StringBuilder buf = new StringBuilder();
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == ' ' || c == '\n' || c == '\r' || c == '\0') {
                if (cnt == 0) continue;
                else break;
            } else
                buf.append((char) c);
            cnt++;
        }
        return buf.toString();
    }

    static char nc() throws IOException {
        int c;
        while ((c = read()) == '\n' || c == '\0' || c == '\r' || c == ' ') ;
        return (char) c;
    }

    static char[] nca(int n) throws IOException {
        char[] a = new char[n];
        for (int i = 0; i < n; i++) {
            a[i] = nc();
        }
        return a;
    }

    static int ni() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    static long nl() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    static double nd() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    static String ns() throws IOException {
        return next();
    }

    static public String nextLine() throws IOException {
        StringBuilder buf = new StringBuilder();
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n' || c == '\r' || c == '\0') {
                if (cnt != 0) break;
                else continue;
            } else
                buf.append((char) c);
            cnt++;
        }
        return buf.toString();
    }

    static int[] nia(int n) throws IOException {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = ni();
        }
        return a;
    }

    static long[] nla(int n) throws IOException {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = nl();
        }
        return a;
    }

    static double[] nda(int n) throws IOException {
        double[] a = new double[n];
        for (int i = 0; i < n; i++) {
            a[i] = nd();
        }
        return a;
    }

    static String[] nsa(int n) throws IOException {
        String[] s = new String[n];
        for (int i = 0; i < n; i++) {
            s[i] = ns();
        }
        return s;
    }

    static private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0,
                BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    static private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    /*---------------------------------output methods-----------------------------------------------*/

    static PrintWriter out = new PrintWriter(System.out);

    /**
     * print single space.
     */
    static void ps() {
        out.print(' ');
    }

    static void pl(int n) {
        out.println(n);
    }

    static void pl(long n) {
        out.println(n);
    }

    static void pl(char c) {
        out.println(c);
    }

    static void pl(double n) {
        out.println(n);
    }

    static void pl(String s) {
        out.println(s);
    }

    /**
     * print YES for true and NO for false.
     */
    static void pl(boolean flag) {
        pl(flag ? "YES" : "NO");
    }

    /**
     * Print new line
     */
    static void PL() {
        out.println();
    }

    static <E> void pl(List<E> a) {
        for (E e : a) {
            p(e);
        }
        PL();
    }

    static void pl(Object o) {
        out.println(o);
    }

    static <E> void p(List<E> a) {
        for (E e : a) {
            p(e);
        }
    }

    static void p(int n) {
        out.print(n);
        ps();
    }

    static void p(long n) {
        out.print(n);
        ps();
    }

    static void p(double d) {
        out.print(d);
        ps();
    }

    static void p(char c) {
        out.print(c);
        ps();
    }

    static void p(String s) {
        out.print(s);
        ps();
    }

    static void p(Object o) {
        out.print(o);
        ps();
    }

    static void pl(int[] a) {
        for (int e : a) {
            p(e);
        }
        PL();
    }

    static void pl(long[] a) {
        for (long e : a) {
            p(e);
        }
        PL();
    }

    static void pl(String[] a) {
        for (String e : a) {
            p(e);
        }
        PL();
    }

    static void pl(char[] a) {
        for (char e : a) {
            p(e);
        }
        PL();
    }

    static void pl(double[] a) {
        for (double e : a) {
            p(e);
        }
        PL();
    }

    static void pl(boolean[] a) {
        for (boolean e : a) {
            out.print(e);
            ps();
        }
        PL();
    }

    static void pl(Object[] a) {
        for (Object e : a) {
            p(e);
        }
        PL();
    }

    static void pl(int[][] a) {
        for (int[] e : a) {
            pl(e);
        }
    }

    static void pl(long[][] a) {
        for (long[] e : a) pl(e);
    }

    static void pl(double[][] a) {
        for (double[] e : a) {
            pl(e);
        }
    }

    static void pl(char[][] a) {
        for (char[] e : a) pl(e);
    }

    static void pl(Object[][] s) {
        for (Object[] e : s) pl(e);
    }

    /**
     * Closes the stream and releases any system resources associated with it.
     * Closing a previously closed stream has no effect.
     */
    static void close() throws IOException {
        if (din != null) din.close();
        out.close();
    }

    /*---------------------------------Frequently used methods------------------------------------------*/

    static void reverse(int[] a) {
        int n = a.length - 1, temp;
        for (int i = 0; i < (n + 1) / 2; i++) {
            temp = a[i];
            a[i] = a[n - i];
            a[n - i] = temp;
        }
    }

    static void reverse(long[] a) {
        long temp;
        int n = a.length - 1;
        for (int i = 0; i < (n + 1) / 2; i++) {
            temp = a[i];
            a[i] = a[n - i];
            a[n - i] = temp;
        }
    }

    static void reverse(double[] a) {
        double temp;
        int n = a.length - 1;
        for (int i = 0; i < (n + 1) / 2; i++) {
            temp = a[i];
            a[i] = a[n - i];
            a[n - i] = temp;
        }
    }

    static double rootX(double a, double b, double c) {
        double d = (b * b) - 4 * a * c;
        return (Math.sqrt(d) - b) / (2 * a);
    }

    static double rootY(double a, double b, double c) {
        double d = (b * b) - 4 * a * c;
        return (-Math.sqrt(d) - b) / (2 * a);
    }

    static int gcd(int a, int b) {
        if (a == 0) {
            return b;
        }
        return gcd(b % a, a);
    }

    static int upperBound(int[] a, int key) {
        int low = 0, high = a.length - 1;
        int ans = -1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (a[mid] >= key) {
                ans = mid;
                high = mid - 1;
            } else low = mid + 1;
        }
        return ans;
    }

    static int lowerBound(int[] a, int key) {
        int low = 0, high = a.length - 1;
        int ans = -1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (a[mid] <= key) {
                ans = mid;
                low = mid + 1;
            } else high = mid - 1;
        }
        return ans;
    }

    static <Number extends Comparable<Number>> int lowerBound(List<Number> a, Number key) {
        int low = 0, high = a.size() - 1;
        int ans = -1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (a.get(mid).compareTo(key) <= 0) {
                ans = mid;
                low = mid + 1;
            } else high = mid - 1;
        }
        return ans;
    }

    static <Number extends Comparable<Number>> int upperBound(List<Number> a, Number key) {
        int low = 0, high = a.size() - 1;
        int ans = -1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (a.get(mid).compareTo(key) >= 0) {
                ans = mid;
                high = mid - 1;
            } else low = mid + 1;
        }
        return ans;
    }

    static boolean isPrime(int n) {
        if (n < 2) return false;
        int i = 1;
        while (++i <= Math.sqrt(n))
            if (n % i == 0) return false;
        return true;
    }//return true or false for prime check

    static boolean isPrime(long l) {
        if (l < 2) return false;
        long i = 1;
        while (++i <= Math.sqrt(l))
            if (l % i == 0) return false;
        return true;
    }

    static long pow(long a, long n) {
        long ans = 1;
        while (n > 0) {
            if ((n & 1) != 0) {
                ans = ((ans % mod) * a) % mod;
            }
            a = (a * a) % mod;
            n >>= 1;
        }
        return ans % mod;
    }

    static long pow(long a, int n) {
        long ans = 1;
        while (n > 0) {
            if ((n & 1) != 0) {
                ans = ((ans % mod) * a) % mod;
            }
            a = (a * a) % mod;
            n >>= 1;
        }
        return ans % mod;
    }

    static String reverse(String s) {
        StringBuilder reversedString = new StringBuilder();
        int n = s.length();
        for (int i = 0; i < n; i++) {
            reversedString.append(s.charAt(i));
        }
        return reversedString.reverse().toString();
    }//Reverse the string;

    static long nCr(long n, long r) {
        if ((n - r) < r) {
            return nCr(n, n - r);
        }
        long ans = 1;
        for (long i = 1; i <= r; i++, n--) {
            if (n % i == 0) {
                ans = n / i * ans;
            } else if (ans % i == 0) {
                ans = ans / i * n;
            } else {
                ans = (ans * n) / i;
            }
        }
        return ans;
    }

    static long rootFloor(long n) {
        double tentativeRoot = Math.sqrt(n);
        long low = (long) tentativeRoot - 3;
        long ans = 0;
        long high = low + 6;
        while (low <= high) {
            long mid = low + (high - low) / 2;
            if ((mid * mid) <= n) {
                ans = mid;
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return ans;
    }

    static long rootHigher(long n) {
        return rootFloor(n) + 1;
    }

    static long rootCeil(long n) {
        double tentativeRoot = Math.sqrt(n);
        long low = (long) tentativeRoot - 3;
        long ans = 0;
        long high = low + 6;
        while (low <= high) {
            long mid = low + (high - low) / 2;
            if ((mid * mid) >= n) {
                ans = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return ans;
    }

    static long rootLower(long n) {
        return rootCeil(n) - 1;
    }

    static long inv(long val) {
        return pow(val, mod - 2);
    }

    static long nCrWithMod(int n, int r) {
        return ((fact[n] * inv(fact[r]) % mod) * inv(fact[n - r])) % mod;
    }

    static void factorial() {
        fact = new long[maxArraySize];
        fact[0] = 1;
        for (int i = 1; i < maxArraySize; i++) {
            fact[i] = (fact[i - 1] * i) % mod;
        }
    }
}

**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 edge cases and scenarios that can maximize the failure probability. The code is designed to find the largest value \( m \) such that the array can be split into exactly \( k \) subarrays, where each subarray has the product of its length and its maximum equal to \( m \). The code has a few potential issues, such as handling edge cases and incorrect logic in the `help` function.

Here are some steps to think through the test input:

1. **Edge Case for \( k = 1 \)**:
   - When \( k = 1 \), \( m \) should always be equal to \( f(1, n) \).
   - A simple test case for this would be an array where all elements are the same, and \( k = 1 \).

2. **Edge Case for \( k > 1 \)**:
   - When \( k > 1 \), the code needs to correctly split the array into subarrays.
   - A test case where the array has a large maximum value in the middle can expose issues in the splitting logic.

3. **Edge Case for No Valid \( m \)**:
   - A test case where no valid \( m \) exists should return \(-1\).
   - This can be achieved by creating an array where the maximum values are not uniformly distributed, making it impossible to find a valid \( m \).

4. **Test Case with Small \( n \)**:
   - A small \( n \) can help ensure the code works correctly without running into time or memory limits.
   - For example, \( n = 3 \) and \( k = 2 \) with an array that cannot be split into two subarrays with the same \( m \).

Given these considerations, here is a small-scale test input that can expose potential bugs in the code:

```plaintext
3 2
1 3 2
```

Explanation:
- \( n = 3 \)
- \( k = 2 \)
- The array is [1, 3, 2]

In this test case:
- \( f(1, 1) = 1 \cdot 1 = 1 \)
- \( f(1, 2) = 2 \cdot 3 = 6 \)
- \( f(1, 3) = 3 \cdot 3 = 9 \)
- \( f(2, 2) = 1 \cdot 3 = 3 \)
- \( f(2, 3) = 2 \cdot 3 = 6 \)
- \( f(3, 3) = 1 \cdot 2 = 2 \)

The goal is to find the largest \( m \) such that the array can be split into 2 subarrays with the same \( m \). The only possible \( m \) is 6, but it is not possible to split the array into two subarrays with \( f(l, r) = 6 \) for both subarrays. Therefore, the correct output should be \(-1\).

This test case should help expose any issues in the code's logic for splitting the array and handling the \( k > 1 \) case.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
#include<bits/stdc++.h>

using i64 = long long;
std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());

void solve() {
    int  n, k;
    int trash;
    std::cin >> n >> k;
    auto ask = [&](int l, int x) {
        std::cout << "? " << l << ' ' << x << '\n';
        std::cout.flush();
        int r;
        std::cin >> r;
        return r;
        };
    int maxv;
    for (int i = n; i >= 1; i--) {  //求出最大值
        if (ask(1, i * n) != n + 1) {
            maxv = i;
            break;
        }
    }
    if (k == 1) {   //表示只分一段的最特殊的情况
        std::cout << "! " << maxv * n << '\n';
        std::cout.flush();
        std::cin >> trash;
        return;
    }
    //然后直接暴力，求出来头部多长可以等于maxv * len，如果枚举到最后分不出来k段的时候接直接break即可
    int res = 0;
    for (int len = n / k; len >= 1; len--) {
        int cnt = 0;  //记录当前存了多少的段
        int m = len * maxv;
        for (int i = 1; i <= n; i++) {
            int r = ask(i, m);
            if (r == n + 1) {
                m = 0;
                break;
            }
            cnt++;
            i = r;
            if (cnt > k) {
                m = 0;
                break;
            }
        }
        if (m != 0) {
            res = m;
            break;
        }
    }
    std::cout << "! " << (res == 0 ? -1 : res) << '\n';
    std::cout.flush();
    std::cin >> trash;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int t = 1;
    std::cin >> t;
    while (t--) {
        solve();
    }
    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:
```plaintext
6 3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
#include<bits/stdc++.h>
using namespace std;
#define il inline
#define fi first
#define se second
#define mk make_pair
#define eb emplace_back
#define rep(i,l,r) for(int i=(l); i<=(r); ++i)
#define rep_(i,l,r) for(int i=(l); i>=(r); --i)
typedef long long lr;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
constexpr int mod1=998244353,mod2=1e9+7;
constexpr db pi=3.141592653589793,eps=1e-9;
constexpr int inf32=0x3f3f3f3f,Inf32=0xcfcfcfcf;
constexpr lr inf64=0x3f3f3f3f3f3f3f3f,Inf64=0xcfcfcfcfcfcfcfcf;
template<typename T>il T Max(T x,T y) { return (x>y)? x:y; }
template<typename T>il T Min(T x,T y) { return (x<y)? x:y; }
template<typename T>il T gcd(T x,T y) { return (!y)? x:gcd(y,x%y); }
template<typename T>il T Abs(T x) { return (x>0)? x:(-x); }
il int Rnd(int l,int r,mt19937 &eng)
{
	uniform_int_distribution<int> uid(l,r);
	return uid(eng);
}
mt19937 eng(chrono::high_resolution_clock::now().time_since_epoch().count());
constexpr int N=10010;
int n,k;
il int Ask(int l,int x)
{
	cout<<"? "<<l<<' '<<x<<endl;
	int val;
	cin>>val;
	return val;
}
il void Ans(int x)
{
	cout<<"! "<<x<<endl;
	int val;
	cin>>val;
}
il void Solve()
{
	cin>>n>>k;
	int mx=0;
	rep_(i,n,1)
	{
		int val=Ask(1,n*i);
		if(val==n)
		{
			mx=i;
			break;
		}
	}
	rep_(i,n/k,1)
	{
		int lim=mx*i,pos=1;
		bool flag=1;
		rep(j,1,k)
		{
			int val=Ask(pos,lim);
			if(val==n+1)
			{
				flag=0;
				break;
			}
			pos=val+1;
		}
		if(flag&&pos==n+1)
		{
			Ans(lim);
			return;
		}
	}
	Ans(-1);
}
int main()
{
#ifdef LOCAL
	string pre="test",isuf="in",osuf="out";
	assert(freopen((pre+"."+isuf).c_str(),"r",stdin));
	assert(freopen((pre+"."+osuf).c_str(),"w",stdout));
#endif
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int T;
	cin>>T;
	while(T--)
		Solve();
	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 generate a challenging test input that exposes the bug in the buggy code, we need to focus on edge cases and scenarios where the algorithm might fail. Here are the steps to think through this:

1. **Understand the Bug**: The buggy code seems to have an issue with how it handles the splitting of the array into subarrays and the calculation of the maximum product.

2. **Edge Cases**:
   - **Single Element Array**: The simplest case where `n = 1` and `k = 1`.
   - **Two Element Array**: A simple case where `n = 2` and `k = 1` or `k = 2`.
   - **Multiple Elements with Repeated Maximum**: An array where the maximum value is repeated multiple times.
   - **Multiple Elements with Different Maximums**: An array where the maximum value is different in different subarrays.
   - **Large `k`**: A case where `k` is close to `n`.

3. **Challenging Scenarios**:
   - **No Valid Split**: An array where no valid split exists.
   - **Multiple Valid Splits**: An array where multiple valid splits exist, but the code might not find the optimal one.

Given these considerations, let's create a test input that is small but challenging:

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

### Explanation:
1. **Test Case 1:**
   - `n = 1`, `k = 1`
   - The array is `[1]`.
   - The only subarray is the entire array, and `f(1, 1) = 1 * 1 = 1`.
   - Expected output: `! 1`

2. **Test Case 2:**
   - `n = 2`, `k = 1`
   - The array is `[1, 2]`.
   - The only subarray is the entire array, and `f(1, 2) = 2 * 2 = 4`.
   - Expected output: `! 4`

3. **Test Case 3:**
   - `n = 3`, `k = 2`
   - The array is `[1, 3, 2]`.
   - Possible splits:
     - `f(1, 1) = 1 * 1 = 1`
     - `f(2, 3) = 2 * 3 = 6`
     - No valid split where both subarrays have the same product.
   - Expected output: `! -1`

4. **Test Case 4:**
   - `n = 4`, `k = 3`
   - The array is `[1, 3, 6, 1]`.
   - Possible splits:
     - `f(1, 1) = 1 * 1 = 1`
     - `f(2, 2) = 1 * 3 = 3`
     - `f(3, 4) = 2 * 6 = 12`
     - No valid split where all three subarrays have the same product.
   - Expected output: `! -1`

This test input covers a range of scenarios, including edge cases and more complex scenarios, which should help expose any bugs in the buggy code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
def query(l,x):
    print("?",l,x)
    res = int(input())
    return res

def test(x,k,n):

    curr = 1
    for _ in range(k):
        if curr > n:  return False
        res = query(curr, x)
        if res > n:  return False
        curr = res + 1

    return True

def main(t):

    n,k = map(int,input().split())

    maximum = n

    for maximum in range(n,0,-1):
        res = query(1,maximum*n)
        if res > n:   continue
        break

    for i in range(n//k,0,-1):
        if test(i*maximum,k,n):
            print("!", i*maximum)
            res = int(input())
            return

    print("!",-1)
    res = int(input())

T = int(input())
t = 1
while t<=T:
    main(t)
    t += 1

**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, let's consider the following steps:

1. **Understand the Bug**: The buggy code has a few issues:
   - It incorrectly handles the case where the maximum value of the array is not found.
   - It does not correctly handle the case where the array cannot be split into `k` subarrays with the same `m` value.

2. **Edge Cases**:
   - **Single Element Array**: This should be straightforward, but it's a good edge case to start with.
   - **Array with All Elements Equal**: This can lead to incorrect splitting if the code doesn't handle it properly.
   - **Array with a Single Large Maximum Element**: This can cause issues if the code doesn't correctly identify the maximum value.
   - **Array with Multiple Maximum Elements**: This can cause issues if the code doesn't handle multiple maximum values correctly.
   - **Array with No Valid Split**: This should return `-1` if no valid split is possible.

3. **Small-Scale Test Input**:
   - We need a small-scale test input that can expose the bug. Let's consider an array with a single large maximum element and some smaller elements.

Given these considerations, a challenging test input could be:

```plaintext
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
```

However, to make it more focused and smaller, let's use:

```plaintext
3
1 1

1
2 2

1

3
```

This test input includes:
- A single-element array.
- A two-element array with a single large maximum element.
- A three-element array with a single large maximum element.

This should be sufficient to expose the bug in the code. Here is the final test input:

```plaintext
3
1 1
1
2 2
1
3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
from sys import *
input = stdin.readline
inputlist = lambda: map(int, stdin.readline().split())

for _ in range(int(input())):
    n, k = inputlist()
    for highest in reversed(range(1, n+1)):
        print("? 1", n*highest, flush = True)
        if int(input()) == n: break
    found = False
    for multiple in reversed(range(highest, highest*(n//k+1), highest)):
        r = 0
        count = 0
        while r < n and count < k:
            print("?", r+1, multiple, flush = True)
            r = int(input())
            if r < n+1: count += 1
        if r == n and count == k:
            found = True
            print("!", multiple, flush = True)
            if int(input()) == -1: break
    if not found:
        print("!", -1, flush = True)
        if int(input()) == -1: break

**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
6 2
1 6 6 1 2 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

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

public class D {
    /**
     * interactive problem.
     * 定义 f(l,r) = (r-l+1) *max( a[l]~a[r] )
     * 每次询问给 l,x，返回 最小的 r 满足 f(l,r) = x
     * 如果不存在返回 n + 1
     * 求最大的 m 满足将数组分成 k 个子数组，f(1,c1) = f(c1+1,c2) = ... = m
     * --> 能否划分
     * <p>
     * N 次询问获取数组最大值
     * 如果能够划分，每个子数组的 f 值一定是 max 的整数倍
     * 看数组能分成多少段 max
     *
     * @param args
     */
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        int t = sc.nextInt();
        out:
        while (t-- > 0) {
            int n = sc.nextInt(), k = sc.nextInt();
            if (n == 1) {
                out.println("! 1");
                out.flush();
                int d = sc.nextInt();
                continue;
            }
            int max = 1;
            for (int i = n; i > 1; i--) {
                int v = i * n;
                out.println("? 1 " + v);
                out.flush();
                int d = sc.nextInt();
                if (d != n + 1) {
                    max = i;
                    break;
                }
            }
            if (max == 1) {
                if (n % k == 0) {
                    out.println("! " + (n / k));
                } else {
                    out.println("! " + (-1));
                }
                out.flush();
                int d = sc.nextInt();
                continue;
            }
            //枚举 m
            int v = max;
            int l = 1;
            int cnt = 0;
            //List<Integer> list = new ArrayList<>();
            while (l <= n) {
                out.println("? " + l + " " + v);
                out.flush();
                int d = sc.nextInt();
                if (d == n + 1) {
                    out.println("! -1");
                    out.flush();
                    int val = sc.nextInt();
                    continue out;
                }
                cnt++;
               // list.add(d - l + 1);
                l = d + 1;
            }

            if (cnt % k == 0) {
                out.println("! " + (max * cnt / k));
            } else {
                out.println("! -1");
            }
            out.flush();
            int d = sc.nextInt();

        }
        out.close();
    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public OutputWriter println(long i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println(double i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println(String i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println() {
            writer.println();
            return this;
        }

        public OutputWriter print(String i) {
            writer.print(i);
            return this;
        }

        public OutputWriter print(long i) {
            writer.print(i);
            return this;
        }

        public OutputWriter print(char i) {
            writer.print(i);
            return this;
        }

        public void flush() {
            writer.flush();
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public double[] nextDoubleArray(int size) {
            double[] a = new double[size];
            for (int i = 0; i < size; i++) a[i] = nextDouble();
            return a;
        }

        public int[] nextIntArray(int size) {
            int[] a = new int[size];
            for (int i = 0; i < size; i++) a[i] = nextInt();
            return a;
        }

        public long[] nextLongArray(int size) {
            long[] a = new long[size];
            for (int i = 0; i < size; i++) a[i] = nextLong();
            return a;
        }

        private int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            return Integer.parseInt(this.next(), 10);
        }

        public long nextLong() {
            return Long.parseLong(this.next(), 10);
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        private static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

**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 code, we need to consider edge cases and scenarios where the algorithm might fail. The key points to focus on are:

1. **Single Element Array**: The code should handle the case where the array has only one element.
2. **Array with All Elements Equal**: This can test the logic for finding the maximum value and the number of segments.
3. **Array with a Large Maximum Value**: This can test the logic for determining the maximum value and the number of segments.
4. **Array with a Small Maximum Value**: This can test the logic for determining the maximum value and the number of segments.
5. **Array with a Mix of Values**: This can test the logic for finding the correct segments and the maximum value.

Given the constraints and the need for a small-scale test input, let's consider the following scenarios:

### Single Element Array
```plaintext
1
1 1
```

### Array with All Elements Equal
```plaintext
3
1 3
1 1 1
```

### Array with a Large Maximum Value
```plaintext
5
1 5
1 2 3 4 10
```

### Array with a Small Maximum Value
```plaintext
4
1 4
1 1 1 2
```

### Array with a Mix of Values
```plaintext
6
1 3
1 3 6 1 2 1
```

### Challenging Test Input
To create a challenging test input, we will combine elements from the above scenarios. Specifically, we will use an array with a mix of values that requires careful handling of the maximum value and the number of segments.

```plaintext
6
1 3
1 3 6 1 2 1
```

This test input will challenge the algorithm to correctly identify the maximum value and the number of segments required to split the array. The array has a mix of values, and the maximum value (6) appears in the middle, which can test the logic for finding the correct segments and the maximum value.

Let's output the test input:

```plaintext
6
1 3
1 3 6 1 2 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

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

public class D {
    /**
     * interactive problem.
     * 定义 f(l,r) = (r-l+1) *max( a[l]~a[r] )
     * 每次询问给 l,x，返回 最小的 r 满足 f(l,r) = x
     * 如果不存在返回 n + 1
     * 求最大的 m 满足将数组分成 k 个子数组，f(1,c1) = f(c1+1,c2) = ... = m
     * --> 能否划分
     * <p>
     * N 次询问获取数组最大值
     * 如果能够划分，每个子数组的 f 值一定是 max 的整数倍
     *
     * @param args
     */
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader sc = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);

        int t = sc.nextInt();
        out:
        while (t-- > 0) {
            int n = sc.nextInt(), k = sc.nextInt();
            if (n == 1) {
                out.println("! 1");
                out.flush();
                int d = sc.nextInt();
                continue;
            }
            int max = 0;
            for (int i = n; i > 0; i--) {
                int v = i * n;
                out.println("? 1 " + v);
                out.flush();
                int d = sc.nextInt();
                if (d != n + 1) {
                    max = i;
                    break;
                }
            }
            //枚举 m
            for (int i = 1; i <= n; i++) {
                int v = i * max;
                int l = 1;
                int cnt = 0;
                while (l < n && cnt < k) {
                    out.println("? " + l + " " + v);
                    out.flush();
                    int d = sc.nextInt();
                    if (d == n + 1) {
                        out.println("! -1");
                        out.flush();
                        int val = sc.nextInt();
                        continue out;
                    }
                    cnt++;
                    l = d + 1;
                }
                if (cnt == k) {
                    if (l == n + 1) {
                        out.println("! " + v);
                        out.flush();
                        int d = sc.nextInt();
                        continue out;
                    }
                }
            }
            out.println("! -1");
            out.flush();
            int d = sc.nextInt();

        }
        out.close();
    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public OutputWriter println(long i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println(double i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println(String i) {
            writer.println(i);
            return this;
        }

        public OutputWriter println() {
            writer.println();
            return this;
        }

        public OutputWriter print(String i) {
            writer.print(i);
            return this;
        }

        public OutputWriter print(long i) {
            writer.print(i);
            return this;
        }

        public OutputWriter print(char i) {
            writer.print(i);
            return this;
        }

        public void flush() {
            writer.flush();
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public double[] nextDoubleArray(int size) {
            double[] a = new double[size];
            for (int i = 0; i < size; i++) a[i] = nextDouble();
            return a;
        }

        public int[] nextIntArray(int size) {
            int[] a = new int[size];
            for (int i = 0; i < size; i++) a[i] = nextInt();
            return a;
        }

        public long[] nextLongArray(int size) {
            long[] a = new long[size];
            for (int i = 0; i < size; i++) a[i] = nextLong();
            return a;
        }

        private int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            return Integer.parseInt(this.next(), 10);
        }

        public long nextLong() {
            return Long.parseLong(this.next(), 10);
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        private static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

**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 edge cases and scenarios that maximize the failure probability. The code has several potential issues, including how it handles the maximum value and the splitting of the array. Let's consider the following scenarios:

1. **Array with all elements being the same**: This can cause issues if the code does not handle equal values correctly.
2. **Array with a single unique maximum value**: This can expose issues in how the code identifies and uses the maximum value.
3. **Array with a small number of elements**: This can test the boundary conditions and ensure the code handles small inputs correctly.
4. **Array with a large number of elements and a specific structure**: This can test the efficiency and correctness of the algorithm in handling larger inputs.

Let's focus on a small-scale test input that is complete and valid:

### Test Input:
```plaintext
1
5 3
1 3 5 2 4
```

### Explanation:
- **n = 5**: The array length is 5.
- **k = 3**: We need to split the array into 3 subarrays.
- **Array = [1, 3, 5, 2, 4]**: The hidden array has elements 1, 3, 5, 2, 4.

### Expected Behavior:
- The code should find the largest value `m` such that the array can be split into 3 subarrays where each subarray has `f(l, r) = m`.
- In this case, the maximum value in the array is 5, and the possible subarrays are:
  - Subarray [1, 3, 5] with `f(1, 3) = 3 * 5 = 15`
  - Subarray [2] with `f(4, 4) = 1 * 2 = 2`
  - Subarray [4] with `f(5, 5) = 1 * 4 = 4`

However, there is no valid `m` that can be used to split the array into 3 subarrays where each subarray has the same `f(l, r)`. Therefore, the expected output should be `-1`.

### Test Input:
```plaintext
1
5 3
1 3 5 2 4
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
#include<bits/stdc++.h>
using namespace std;
#define int long long
inline int read(){
	int x=0,k=1;char c=getchar();
	while(c<'0'||c>'9'){
		if(c=='-')k=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
	return x*k;
}
const int N=2e5+5;
int a[N];
void sol(){
	int n,k;
	cin>>n;
	if(n==-1)exit(0);
	cin>>k;
	if(k==-1)exit(0);
	int x;
	int ma;
	for(int i=1;i<=n;++i){
		cout<<"? "<<1<<' '<<n*i<<endl;
		cin>>x;
		if(x==-1)exit(0);
		if(x==n){
			ma=i;
			break;
		}
	}
	bool f=1;
	for(int m=n*ma/k;m>0;m-=ma){
		int l=0,c=0;
		while(l<n){
			cout<<"? "<<l+1<<' '<<m<<endl;
			cin>>l;
			if(l==-1)exit(0);
			++c;
		}
		if(l==n&&c==k){
			f=0;
			cout<<"! "<<m<<endl;
			break;
		}
	}
	if(f)cout<<"! -1"<<endl;
	int h;
	cin>>h;
	if(h==-1)exit(0);
}
signed main(){
	int T;
	cin>>T;
	while(T--)sol();
}

**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 edge cases and scenarios that can maximize the failure probability. Here are the steps to think through this:

1. **Understand the Bug**: The buggy code seems to have issues with the way it handles the queries and the logic for determining the maximum value `m` that can split the array into `k` subarrays.

2. **Edge Cases**:
   - **Small Arrays**: Test with small arrays to ensure the basic logic is correct.
   - **Large Arrays**: Test with large arrays to see how the code handles more complex scenarios.
   - **Single Element Arrays**: Test with arrays of length 1 to see if the code handles them correctly.
   - **Uniform Arrays**: Test with arrays where all elements are the same.
   - **Non-Uniform Arrays**: Test with arrays where elements are different to see if the code can handle varied values.

3. **Specific Test Case**:
   - Let's consider an array where the maximum value is not uniformly distributed and see if the code can handle it correctly.
   - For example, an array like `[1, 2, 3, 1, 1]` with `k = 2` should be challenging because the maximum value `3` is only present in the middle, and the code needs to correctly determine the split.

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

```plaintext
1
5 2
1
2
3
1
1
```

This test case has the following properties:
- The array is `[1, 2, 3, 1, 1]`.
- The length `n` is 5.
- The number of subarrays `k` is 2.
- The maximum value in the array is 3, and it is only present in the middle.

This input should challenge the buggy code to correctly determine the largest value `m` such that the array can be split into 2 subarrays with the product of their length and their maximum equal to `m`.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
constexpr int MAXN = 1e6 + 7;
constexpr int INF = 2e9;
constexpr ll INFF = 1e18;
constexpr ll MOD = 998244353;
#define mkp make_pair
#define F first
#define S second
#define pb emplace_back
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()

int ask(int l, int x) {
  cout << "? " << l << ' ' << x << endl;
  int r;
  cin >> r;
  return r;
}

int32_t main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n, k;
    cin >> n >> k;
    int mx = 0;
    for (int i = 1; i <= n; i++) {
      int r = ask(1, n * i);
      if (r == n) {
        mx = i;
        break;
      }
    }
    bool have = 0;
    for (int i = 1; i * k <= n; i++) {
      int l = 1;
      bool ok = 1;
      for (int j = 1; j <= k; j++) {
        int r = ask(l, i * mx);
        if (r == n + 1) {
          ok = 0;
          break;
        }
        l = r + 1;
      }
      if (l != n + 1)
        ok = 0;
      if (ok) {
        have = 1;
        cout << "! " << i * mx << endl;
        int ret;
        cin >> ret;
        if (ret == -1)
          exit(0);
        break;
      }
    }
    if (!have) {
      cout << "! " << -1 << endl;
      int ret;
      cin >> ret;
      if (ret == -1)
        exit(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:
```plaintext
3
6 3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
t = int(input())
for i in range(0, t):
    n, k = list(map(int, input().split()))
    ma = 0
    p = 1
    for g in range(1, n + 1):
        print("?", p, g * n)
        ans = int(input())
        if ans == n:
            ma = g
            break
    f = False
    for g in range(1, n // k + 1):
        d = 0
        st = 1
        while True:
            print("?", st, g * ma)
            ans = int(input())
            if ans == n + 1:
                break
            d += 1
            if ans == n and d == k:
                print("!", g * ma)
                f = True
                break
            st = ans
            st += 1
            if st > n:
                break
        if f:
            break
    if not f:
        print("!", -1)
    ans = int(input())

**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
5 2
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Cat, Fox and Maximum Array Split
time_limit_ms: 3000
memory_limit_mb: 256
Description: This is an interactive problem.

Fox gave Cat two positive integers $$$n$$$ and $$$k$$$. She has a hidden array $$$a_1, \ldots , a_n$$$ of length $$$n$$$, such that $$$1 \leq a_i \leq n$$$ for every $$$i$$$. Now they are going to play the following game:

For any two integers $$$l, r$$$ such that $$$1 \leq l \leq r \leq n$$$, define $$$f(l, r) = (r - l + 1) \cdot \max\limits_{x=l}^r a_x$$$. In other words, $$$f(l, r)$$$ is equal to the maximum of the subarray $$$a_l, \ldots, a_r$$$ multiplied by its size.

Cat can ask Fox at most $$$2 n$$$ questions about the array. He will tell her two integers $$$l$$$ and $$$x$$$ ($$$1 \leq l \leq n, 1 \leq x \leq 10^9$$$), and she will tell him one integer $$$p$$$ as the answer — the smallest positive integer $$$r$$$ such that $$$f(l, r) = x$$$, or $$$n+1$$$ if no such $$$r$$$ exists.

Now, Cat needs to find the largest value $$$m$$$ such that there exists a sequence $$$c_1, \ldots, c_{k-1}$$$ such that $$$1 \leq c_1 < \ldots < c_{k-1} < n$$$ and $$$f(1, c_1) = f(c_1 + 1, c_2) = \ldots = f(c_{k-1}+1, n) = m$$$. If no such $$$m$$$ exists, he should indicate this and take $$$-1$$$ as the answer. Note that for $$$k = 1$$$, $$$m$$$ is always equal to $$$f(1, n)$$$.

In other words, the goal is to find the largest $$$m$$$ such that you can split the array into exactly $$$k$$$ subarrays ($$$k$$$ is the constant given to you in the beginning of the interaction) so that all the subarrays have the product of their length and their maximum equal to $$$m$$$, or determine that no such $$$m$$$ exists. Every element should belong in exactly one of the subarrays.

Cat doesn't know what he should do, so he asked you to play the game for him.

Input: None

Output: None

Examples:
input:
3
1 1

1
2 2

1

3

1
6 3

7

2

3

6

1
output:
! 1

? 1 1

? 2 1

! -1

? 1 9

? 1 6

? 3 6

? 4 6

! 6

Note: The hidden arrays in the three testcases are $$$[1]$$$, $$$[1, 2]$$$ and $$$[1, 3, 6, 1, 2, 1]$$$. In the second testcase, no split satisfies the constraints, so the answer is $$$-1$$$.

The answer for the first query of the third testcase is $$$7$$$ since no valid $$$r$$$ exists. For the second query of the third testcase, since $$$2 \cdot \max(1, 3) = 6$$$, we will get $$$2$$$ as the answer, since $$$r = 1$$$ doesn't satisfy the constraint.

The sample interaction guessed all three answers ($$$1, -1$$$ and $$$6$$$) correctly, so it received $$$1$$$ after each answer.

Buggy Code:
t = int(input())
for i in range(0, t):
    n, k = list(map(int, input().split()))
    ma = 0
    p = 1
    for g in range(1, n + 1):
        print("?", p, g * n)
        ans = int(input())
        if ans == n:
            ma = g
            break
    f = False
    for g in range(1, n // k + (n % k == 0)):
        d = 0
        st = 1
        while True:
            print("?", st, g * ma)
            ans = int(input())
            if ans == n + 1:
                break
            d += 1
            if ans == n and d == k:
                print("!", g * ma)
                f = True
                break
            st = ans
            st += 1
            if st > n:
                break
        if f:
            break
    if not f:
        print("!", -1)
    ans = int(input())

**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
3
1 1
2 2
6 3
```