**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <bits/stdc++.h>
//#define START ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long
#define endl '\n'
#define debug(a) cout<<#a<<" = "<<a<<endl
using namespace std;
    void solve()
    {
      int n,m;
      cin>>n>>m;
      int a[n+1];
    vector<int> v;
    for(int i=0;i<n;i++)
        cin>>a[i];

    for(int i=0;i<m;i++)
        {
          char c;
          cin>>c;
          int l,r;
          cin>>l>>r;
          for(int i=1;i<n+1;i++)
          {
              if(l<=a[i-1]&&a[i-1]<=r)
              {
                  if(c=='-'){a[i-1]-=1;}
                  else if(c=='+') a[i-1]+=1;
              }
          }
          int ans=0;
          for(int i=0;i<n;i++)
          {
              if(a[i]>=ans){ans=a[i];}
          }
          v.push_back(ans);
        }
        for(int i=0;i<n;i++)
        cout<<v[i]<<' ';return;

    }
    int main()
    {
    int t;
    cin>>t;
    while(t--)
    {

    solve();
    }
    }

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

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

Think step by step.

Response:
```plaintext
1
5 3
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

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

using namespace std;

#define int long long

void red() {
  int n, m;
  cin >> n >> m;
  int amax = INT_MIN;
  vector<int> a(n);
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
    amax = max(amax, a[i]);
  }
  for (int i = 0; i < n; ++i) {
    char ch;
    int l, r;
    cin >> ch >> l >> r;
    if (amax >= l && amax <= r) {
      if (ch == '+')
        amax++;
      else
        amax--;
    }
    cout << amax << " ";
  }
  cout << endl;
  return;
}

int32_t main() {
  int t;
  cin >> t;
  while (t--)
    red();
  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
1
3 3
1 2 3
+ 1 3
- 1 2
+ 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <iostream>
using namespace std;
int main(){
    int t,n,m;cin>>t;
    while(t--){
       cin>>n>>m;int x,mx=0;
       for(int i=0;i<n;i++){
        cin>>x;mx=max(x,mx);
       }
       int l,r; char c;
       for(int i=0;i<n;i++){
            cin>>c>>l>>r;
            if(c=='-' && mx>=l&&mx<=r) cout<<--mx;
            else if(c== '+'&& mx>=l&&mx<=r) cout<<++mx;
            else  cout<<mx;
            cout<<" ";
       }
       puts("");
    }
    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
3
5 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
5 5
1 1 1 1 1
+ 1 1
- 1 1
+ 1 1
- 1 1
+ 1 1
5 5
1 2 3 4 5
+ 3 3
- 2 2
+ 4 4
- 1 1
+ 5 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
def solve_test_case():
    n, m = map(int, input().split())
    a = list(map(int, input().split()))

    max_val = max(a)
    second_max = max(x for x in a if x != max_val) if len(set(a)) > 1 else max_val
    results = []

    for _ in range(m):
        op, l, r = input().split()
        l, r = int(l), int(r)

        if op == '+':
            if l <= max_val <= r:
                max_val += 1
        else:  # op == '-'
            if l <= max_val <= r:
                if second_max == max_val:
                    max_val -= 1
                elif l <= second_max <= r:
                    max_val = second_max
                else:
                    max_val -= 1

        results.append(max_val)

    return results

t = int(input())
for _ in range(t):
    print(*solve_test_case())

**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
5 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
5 5
5 5 5 5 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
5 5
1 1 2 2 3
+ 1 3
- 1 3
+ 1 3
- 1 3
+ 1 3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
a = int(input())
for _ in range(a):
    b, c = map(int, input().split())
    t = list(map(int, input().split()))
    st = set(t)
    ans=[]
    for _ in range(b):
        s, l, r = input().split()
        l1 = int(l)
        r1 = int(r)
        to_add = set()
        to_remove = set()
        for i in st:
            if l1 <= i <= r1:
                to_remove.add(i)
                if s == "+":
                    to_add.add(i + 1)
                else:
                    to_add.add(i - 1)
        st.difference_update(to_remove)
        st.update(to_add)

        ans.append(max(st))
    for i in ans:
        print(i,end=" ")
    print()

**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 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
t=int(input())
for _ in range (t):
    m,n=map(int, input().split())
    L=list(map(int, input().split()))
    for _ in range(m):
        c,l,r=map(str, input().split())
        l=int(l)
        r=int(r)
        for i in range(len(L)):
            if l<=L[i]<=r and c=='+':
                L[i]+=1
            if l<=L[i]<=r and c=='-':
                L[i]-=1
        a=max(L)
        print (a,end=" ")
    print()

**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 create a challenging test input that exposes the bug in the provided buggy code, we need to focus on edge cases and scenarios that can maximize the failure probability. The buggy code has a few potential issues:

1. **Incorrect Handling of Operations**: The code processes both `+` and `-` operations in the same loop, which can lead to incorrect updates if the operations are not applied in the correct order.
2. **Array Size and Operation Count**: The code should handle large arrays and a large number of operations efficiently.
3. **Edge Cases**: The code should handle edge cases where the range of the operation might not overlap with the array elements.

Given these points, let's create a small-scale test input that includes the following scenarios:

1. An array with all elements being the same.
2. Operations that do not affect any elements.
3. Operations that affect only a subset of elements.
4. Operations that result in elements becoming negative or very large.

Here is the test input:

```plaintext
3
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
5 5
1 2 3 4 5
+ 1 1
- 2 2
+ 3 3
- 4 4
+ 5 5
5 5
1000000000 1000000000 1000000000 1000000000 1000000000
- 1000000000 1000000000
+ 999999999 1000000000
- 999999998 1000000000
+ 999999997 1000000000
- 999999996 1000000000
```

Explanation:
1. **Test Case 1**:
   - Initial array: `[1, 1, 1, 1, 1]`
   - Operations:
     - `+ 2 3`: No effect.
     - `- 4 5`: No effect.
     - `+ 1 6`: All elements become `2`.
     - `- 2 5`: All elements become `1`.
     - `+ 1 8`: All elements become `2`.
   - Expected output: `1 1 2 1 2`

2. **Test Case 2**:
   - Initial array: `[1, 2, 3, 4, 5]`
   - Operations:
     - `+ 1 1`: Only the first element becomes `2`.
     - `- 2 2`: Only the second element becomes `1`.
     - `+ 3 3`: Only the third element becomes `4`.
     - `- 4 4`: Only the fourth element becomes `3`.
     - `+ 5 5`: Only the fifth element becomes `6`.
   - Expected output: `2 2 4 4 6`

3. **Test Case 3**:
   - Initial array: `[1000000000, 1000000000, 1000000000, 1000000000, 1000000000]`
   - Operations:
     - `- 1000000000 1000000000`: All elements become `999999999`.
     - `+ 999999999 1000000000`: All elements become `1000000000`.
     - `- 999999998 1000000000`: All elements become `999999999`.
     - `+ 999999997 1000000000`: All elements become `1000000000`.
     - `- 999999996 1000000000`: All elements become `999999999`.
   - Expected output: `999999999 1000000000 999999999 1000000000 999999999`

This test input should expose the issues in the buggy code by covering a variety of edge cases and ensuring that the operations are applied correctly.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
import java.util.*;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for(int sfndjfkh  = 0; sfndjfkh < t;sfndjfkh++){

            int n = sc.nextInt();
            int m = sc.nextInt();
            long a[] = new long[n];
            for(int i = 0;i<n;i++){
                a[i] = sc.nextLong();
            }
            Arrays.sort(a);

            char c2[] = new char[m];
            long l2[] = new long[m];
            long r2[] = new long[n];
            for(int i = 0;i<m;i++){
                 c2[i] = sc.next().charAt(0);
                 l2[i]= sc.nextLong();
                 r2[i] = sc.nextLong();
            }
            for(int i = 0;i<m;i++){
                char c = c2[i];
                long l = l2[i];
                long r = r2[i];
                if(c == '+'){
                    if(l <= a[n-1] && r >= a[n-1]){
                        a[n-1]++;

                    }
                    System.out.print(a[n-1] + " ");
                }else{
                    if(l <= a[n-1] && r >= a[n-1]){
                        a[n-1]--;

                    }
                    System.out.print(a[n-1] + " ");
                }
            }
            System.out.println();
        }
    }
}

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

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

Think step by step.

Response:
```plaintext
1
3 3
1 2 3
+ 1 3
- 2 2
+ 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
import java.util.Scanner;

public class Main {
    public static void getMax(int arr[], char c, int l, int r,int index,int ans[]) {
        for (int i = 0; i < arr.length; i++) {
            if (c == '+' && arr[i] >= l && arr[i] <= r) {
                arr[i]++;
            } else if (c == '-' && arr[i] >= l && arr[i] <= r) {
                arr[i]--;
            }
        }
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr[i]);
        }
        ans[index]=max;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int test = 0; test < t; test++) {
            int n = sc.nextInt();
            int op = sc.nextInt();
            int arr[] = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = sc.nextInt();
            }
            int ans[]=new int[op];
            int index=0;
            for (int i = 0; i < op; i++) {
                char c = sc.next().charAt(0);
                int l = sc.nextInt();
                int r = sc.nextInt();
                getMax(arr, c, l, r,index,ans);
                index++;
            }
            for(int i=0;i<n;i++){
                System.out.print(ans[i]+" ");
            }
            System.out.println();  // Move to the next line after each test case
        }
        sc.close();
    }
}

**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
5 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
5 5
1 2 3 4 5
- 1 1
- 2 2
- 3 3
- 4 4
- 5 5
5 5
1 2 3 4 5
+ 1 1
+ 2 2
+ 3 3
+ 4 4
+ 5 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 1e9

void solve() {
    int n,m;
    cin>>n>>m;
    ll a[n];
    vector<int > v;
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<m;i++){
        char c;
        int l,r;cin>>c>>l>>r;
        if(c=='+'){
            for(int j=0;j<n;j++){
                if(a[j]>=l&&a[j]<=r){
                    a[j]++;
                }
            }
            ll maxnum=a[0];
            for(int j=1;j<n;j++) maxnum=maxnum>a[j]?maxnum:a[j];
            v.push_back(maxnum);
        }
        else{
            for(int j=0;j<n;j++){
                if(a[j]>=l&&a[j]<=r){
                    a[j]--;
                }
            }
            ll maxnum=a[0];
            for(int j=1;j<n;j++) maxnum=maxnum>a[j]?maxnum:a[j];
            v.push_back(maxnum);
        }
    }
    for(auto i:v){
        cout<<i<<" ";
    }
    cout<<"\n";
}
int main() {
    //std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t=1;
    cin >> t;
    while (t--)
        solve();
}

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

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

Think step by step.

Response:
```plaintext
2
5 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
5 5
10 9 8 7 6
- 6 10
+ 6 10
- 6 10
+ 6 10
- 6 10
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <limits>
#include <cmath>
#include <numeric>
#define pb push_back
#define debug(x) cout<<#x <<" = "<<x<<endl;
#define ansYes cout <<"YES"<<endl;
#define ansNo cout <<"NO"<<endl;
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using vs = vector<string>;
void solve()
{
    int n, m;
    cin >> n >> m;
    vi arr(n);
    for (int i =0;i < n; i++){
        cin >> arr[i];
    }
    for (int i =0; i < m; i++){
        char c;
        int l, r;
        cin >> c >> l >> r;
        if (c == '+'){
            for_each(arr.begin(), arr.end(), [=](int &x){
                if (x <= r && x >= l){
                    x++;
                }
            });
        }
        else{
            for_each(arr.begin(), arr.end(), [=](int &x){
                if (x <= r && x >= l){
                    x--;
                }
            });
        }
        cout << *max_element(arr.begin(), arr.end()) << " ";
    }
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int t= 1;
    cin >> t;

    while (t--){
        solve();
    }
}

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

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

Think step by step.

Response:
```plaintext
1
3 4
1 2 3
+ 1 3
- 1 2
+ 2 3
- 3 3
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
t = int(input())
ans = [[] for _ in range(t)]
for i in range(t):
    n,m = map(int, input().split())
    lst = list(map(int, input().split()))
    for e in range(m):
        lst_tmp = lst.copy()
        action = input().split()
        for j in range(n):
            if lst_tmp[j]>=int(action[1]) and lst_tmp[j]<=int(action[2]):
                if action[0] == '+':
                    lst_tmp[j] += 1
                else:
                    lst_tmp[j] -= 1

        ans[i].append(max(lst_tmp))
        lst = lst_tmp.copy()

for an in ans:
    print(*an)

**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
5 3
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
5 3
1000000000 999999999 1000000000 1 1
- 1 1000000000
+ 1 1000000000
- 1 1000000000
5 3
1 1 1 1 1
+ 1 1
- 1 1
+ 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
def solve():
    n,m=map(int,input().split())
    nums=list(map(int,input().split()))
    ans=[]
    for i in range(m):
        op=list(map(str,input().split()))
        if op[0]=='+':
            for i in range(n):
                if nums[i]<=int(op[2]) and nums[i]>=int(op[1]):
                    nums[i]+=1
                else:
                    continue
        else:
            for i in range(n):
                if nums[i]<=int(op[2]) and nums[i]>=int(op[1]):
                    nums[i]-=1
                else:
                    continue
        ans.append(max(nums))
    print(*ans)

for i in range(int(input())):
    solve()

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

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

Think step by step.

Response:
```plaintext
2
5 3
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
1 1
1
- 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
import java.util.*;
public class solution{
    public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();
			int m = sc.nextInt();
			int[] arr = new int[n];

			int [] arr2 = new int [m];
			for (int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
			}
			int k = 0 ;
			while (m-- > 0) {
				char c = sc.next().charAt(0);
				int l = sc.nextInt();
				int r = sc.nextInt();
				int max = 0 ;
				for (int j = 0; j < n; j++) {
					if (arr[j] >= l && arr[j] <= r) {
						if (c == '+') {
							arr[j]++;
						} else {
							arr[j]--;
						}

					}
					max = Math.max(max, arr[j]);
				}
				arr2[k]=max;
				k++;
			}
			for (int i = 0; i < arr2.length; i++) {
				System.out.print(arr2[i] + " ");
			}
			System.out.println();
		}
	}
}

**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 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
import java.util.*;

public class Index_Maximum_Value {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();  // Number of test cases
        while (t-- > 0) {
            int n = sc.nextInt();  // Size of the array
            int m = sc.nextInt();  // Number of operations
            int[] ar = new int[n]; // Array input
            int max = Integer.MIN_VALUE; // Store max value in array

            // Reading the array and finding the maximum value
            for (int i = 0; i < n; i++) {
                ar[i] = sc.nextInt();
                max = Math.max(ar[i], max);
            }

            for (int i = 0; i < m; i++) {
                char op = sc.next().charAt(0);
                int l = sc.nextInt();
                int r = sc.nextInt();

                if (l <= max && max <= r) {
                    if (op == '+') {
                        max++;
                    } else if (op == '-') {
                        max--;
                    }
                }

                // Output the current value of max after the query
                System.out.print(max + " ");
            }
            System.out.println();
        }
    }
}

**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 5
1 2 3 4 5
+ 1 3
- 3 5
+ 1 5
- 1 2
+ 4 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// Function to find the lower bound index for range operation
int lowerBound(const vector<int>& a, int l) {
    return lower_bound(a.begin(), a.end(), l) - a.begin();
}

// Function to find the upper bound index for range operation
int upperBound(const vector<int>& a, int r) {
    return upper_bound(a.begin(), a.end(), r) - a.begin() - 1;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while (t--) {
        int n, m;
        cin >> n >> m;

        vector<int> a(n);
        for (int i = 0; i < n; ++i) {
            cin >> a[i];
        }

        // Sort the array for binary search
        sort(a.begin(), a.end());

        vector<int> results;
        for (int i = 0; i < m; ++i) {
            char op;
            int l, r;
            cin >> op >> l >> r;

            // Find the range of elements that need to be updated
            int start = lowerBound(a, l);
            int end = upperBound(a, r);

            if (start <= end) {
                // Apply the operation for the found range
                for (int j = start; j <= end; ++j) {
                    if (op == '+') {
                        a[j]++;
                    } else { // op == '-'
                        a[j]--;
                    }
                }
                // Sort only the modified part to maintain order
                sort(a.begin() + start, a.begin() + end + 1);
            }

            // Maximum value is the last element in the sorted array
            results.push_back(a.back());
        }

        // Output all results for this test case
        for (int i = 0; i < results.size(); ++i) {
            cout << results[i] << " ";
        }
        cout << "\n";
    }

    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
3
3 2
1 2 3
+ 1 3
- 1 3
4 2
1 2 2 3
+ 2 2
- 2 3
5 3
1 1 1 1 1
+ 1 1
- 1 1
+ 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int lower_bound(const vector<int>& sorted_array, int val) {
    int low = 0, high = sorted_array.size();
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (sorted_array[mid] < val) {
            low = mid + 1;
        } else {
            high = mid;
        }
    }
    return low;
}

int upper_bound(const vector<int>& sorted_array, int val) {
    int low = 0, high = sorted_array.size();
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (sorted_array[mid] <= val) {
            low = mid + 1;
        } else {
            high = mid;
        }
    }
    return low;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    while (t--) {
        int n, m;
        cin >> n >> m;

        vector<int> a(n);
        for (int i = 0; i < n; ++i) {
            cin >> a[i];
        }

        vector<pair<int, int>> operations(m);
        vector<char> op_types(m);
        for (int i = 0; i < m; ++i) {
            char op;
            int l, r;
            cin >> op >> l >> r;
            operations[i] = {l, r};
            op_types[i] = op;
        }

        vector<int> sorted_array = a;
        sort(sorted_array.begin(), sorted_array.end());

        vector<int> results;

        for (int i = 0; i < m; ++i) {
            char op = op_types[i];
            int l = operations[i].first;
            int r = operations[i].second;

            int left_index = lower_bound(sorted_array, l);
            int right_index = upper_bound(sorted_array, r);

            if (op == '+') {
                for (int j = left_index; j < right_index; ++j) {
                    sorted_array[j]++;
                }
            } else if (op == '-') {
                for (int j = left_index; j < right_index; ++j) {
                    sorted_array[j]--;
                }
            }

            int max_value = *max_element(sorted_array.begin(), sorted_array.end());
            results.push_back(max_value);
        }

        for (int i = 0; i < m; ++i) {
            cout << results[i] << ' ';
        }
        cout << '\n';
    }

    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
3
5 3
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
5 3
1 2 3 4 5
- 1 5
+ 1 5
- 1 5
1 1
1
- 1 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
def solve():
    import sys
    input = sys.stdin.read
    data = input().split()

    index = 0
    t = int(data[index])
    index += 1
    results = []

    for _ in range(t):
        n = int(data[index])
        m = int(data[index + 1])
        index += 2
        a = list(map(int, data[index:index + n]))
        index += n

        max_values = []
        for _ in range(m):
            op = data[index]
            l = int(data[index + 1])
            r = int(data[index + 2])
            index += 3

            if op == '+':
                for i in range(n):
                    if l <= a[i] <= r:
                        a[i] += 1
            else:
                for i in range(n):
                    if l <= a[i] <= r:
                        a[i] -= 1

            max_values.append(max(a))

        results.append(" ".join(map(str, max_values)))

    print("\n".join(results))

# To run the function
solve()

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

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

Think step by step.

Response:
```plaintext
1
5 5
1 2 3 4 5
+ 1 5
- 1 5
+ 1 5
- 1 5
+ 1 5
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Index and Maximum Value
time_limit_ms: 1000
memory_limit_mb: 256
Description: After receiving yet another integer array $a_1, a_2, \ldots, a_n$ at her birthday party, Index decides to perform some operations on it.

Formally, there are $m$ operations that she is going to perform in order. Each of them belongs to one of the two types:

  * $\texttt{+ l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i + 1$.    * $\texttt{- l r}$. Given two integers $l$ and $r$, for all $1 \leq i \leq n$ such that $l \leq a_i \leq r$, set $a_i := a_i - 1$.

For example, if the initial array $a = [7, 1, 3, 4, 3]$, after performing the operation $\texttt{+} \space 2 \space 4$, the array $a = [7, 1, 4, 5, 4]$. Then, after performing the operation $\texttt{-} \space 1 \space 10$, the array $a = [6, 0, 3, 4, 3]$.

Index is curious about the maximum value in the array $a$. Please help her find it after each of the $m$ operations.

Input: Each test consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n \leq 10^5$, $1 \leq m \leq 10^5$) — the length of the array and the number of operations.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the initial array $a$.

Then $m$ lines follow, each line corresponds to the operation, in the following format: $\texttt{c l r}$ ($c \in \\{\texttt +, \texttt -\\}$, $l$ and $r$ are integers, $1 \leq l \leq r \leq 10^9$) — the description of the operation.

Note that the elements $a_i$ may not satisfy $1\le a_i\le 10^9$ after some operations, as it is shown in the example.

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

Output: For each test case, output one single line containing $m$ integers, with the $i$-th of them describing the maximum value of the array after the $i$-th operation.

Examples:
input:
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
output:
4 4 4 5 5
5 5 4 4 3
1 1 2 1 2
0
1000000001

Note: In the first test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the second operation, the array becomes equal $[1,2,4,2,1]$. The maximum value is $4$.    * After the third operation, the array becomes equal $[2,3,4,3,2]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.    * After the fifth operation, the array becomes equal $[3,4,5,4,3]$. The maximum value is $5$.

In the second test case, the process of the operations is listed below:

  * After the first operation, the array becomes equal $[2,4,4,5,5]$. The maximum value is $5$.    * After the second operation, the array becomes equal $[3,4,4,5,5]$. The maximum value is $5$.    * After the third operation, the array becomes equal $[3,3,3,4,4]$. The maximum value is $4$.    * After the fourth operation, the array becomes equal $[2,2,2,4,4]$. The maximum value is $4$.    * After the fifth operation, the array becomes equal $[1,1,1,3,3]$. The maximum value is $3$.

Buggy Code:
n = int(input())
res = []
for i in range(n):
    res_ls = list()
    n, m = input().split(maxsplit=2)
    ls = list(map(int,input().split(maxsplit=int(n))))
    ops = [input() for _ in range(int(m))]
    max_val = list()
    for operation in ops:
        sign, l, r = operation.split(maxsplit=3)

        if sign == "+":
            ls = list(map(lambda x: x + 1 if int(l) <= x <= int(r) else x, ls))

        else:
            ls = list(map(lambda x: x - 1 if int(l) <= x <= int(r) else x, ls))

        max_val.append(str(max(ls)))

    print(" ".join(max_val))

**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
5
5 5
1 2 3 2 1
+ 1 3
- 2 3
+ 1 2
+ 2 4
- 6 8
5 5
1 3 3 4 5
+ 1 4
+ 2 3
- 4 5
- 3 3
- 2 6
5 5
1 1 1 1 1
+ 2 3
- 4 5
+ 1 6
- 2 5
+ 1 8
1 1
1
- 1 1
1 1
1000000000
+ 1000000000 1000000000
```