**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
#include <iostream>

using namespace std;

int main()
{
    int t;cin>>t;
    int x,y;
    for(int s=1;s<=t;s++){
        cin>>x>>y;
        if(abs(y-abs(x))<=abs(x)||abs(y-abs(x))<=abs(x)+1) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to consider edge cases that the code might handle incorrectly. The buggy code uses the condition `if(abs(y-abs(x))<=abs(x)||abs(y-abs(x))<=abs(x)+1)` to determine if Monocarp can collect a coin. This condition is flawed because it does not correctly account for all possible moves and the falling of coins.

### Step-by-Step Analysis:
1. **Understanding the Bug**:
   - The condition `abs(y-abs(x))<=abs(x)` or `abs(y-abs(x))<=abs(x)+1` is not correct because it does not consider the diagonal and vertical/horizontal moves correctly.
   - The character can move in 8 directions, and the coins fall down by 1 unit each second.

2. **Edge Cases**:
   - **Diagonal Movement**: The character can move diagonally, and the coins fall down. The condition should account for this.
   - **Vertical and Horizontal Movement**: The character can move vertically or horizontally, and the coins fall down. The condition should account for this.
   - **Coin Falling**: The coins fall down by 1 unit each second, which can change the relative positions.

3. **Test Input**:
   - We need a test case where the character can collect a coin but the buggy code incorrectly outputs "NO".
   - We also need a test case where the character cannot collect a coin but the buggy code incorrectly outputs "YES".

### Challenging Test Input:
```plaintext
4
1 2
2 1
-2 2
-1 -2
```

### Explanation:
- **Coin (1, 2)**:
  - The character can move to (1, 1) in the first second, and the coin falls to (1, 1), so the character can collect it.
  - The buggy code should output "YES".

- **Coin (2, 1)**:
  - The character can move to (1, 1) in the first second, and the coin falls to (2, 0), so the character cannot collect it.
  - The buggy code should output "NO".

- **Coin (-2, 2)**:
  - The character can move to (-1, 1) in the first second, and the coin falls to (-2, 1), so the character can collect it.
  - The buggy code should output "YES".

- **Coin (-1, -2)**:
  - The character can move to (-1, -1) in the first second, and the coin falls to (-1, -3), so the character cannot collect it.
  - The buggy code should output "NO".

This test input should expose the bug in the provided code by showing incorrect outputs for some of the coins.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
#include<bits/stdc++.h>
#define int long long
#define i128 __int128
#define endl '\n'
const int N=1e6+6;
#define gcd __gcd
int mod=1e9+7;
#define FAST ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
using namespace std;
typedef pair<int,int> PII;
int fastPow(int a,int n,int mod)
{
	 int ans=1;
	 a%=mod;
	 while(n)
	 {
	 	 if(n&1) ans=(ans*a)%mod;
	 	 	 a=(a*a)%mod;
	 	 	 n>>=1;

	 }
	 return ans;
}
signed main(){
    FAST
    int tt;cin>>tt;
    while(tt--)
    {
    	 int x,y;
    	 cin>>x>>y;
    	if(y==0)
    	{
    		 cout<<"YES"<<endl;
    	}
    	else if(x<y)
    	{
    		 cout<<"YES"<<endl;
    	}
    	else
    	{
    		 cout<<"NO"<<endl;
    	}

    }
}

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to focus on edge cases and scenarios where the logic in the code might fail. The main issue in the buggy code is the incorrect condition for determining whether Monocarp can collect a coin. Specifically, the condition `if(x < y)` is not sufficient to determine if Monocarp can reach the coin.

### Step-by-Step Analysis:
1. **Initial Position**: Monocarp starts at (0, 0).
2. **Movement**: Monocarp can move in any of the 8 directions: up, up-right, right, down-right, down, down-left, left, up-left.
3. **Coin Movement**: Each coin falls down by 1 unit every second.
4. **Objective**: Determine if Monocarp can reach each coin before it falls off the screen.

### Key Observations:
- **Correct Condition**: Monocarp can reach a coin at (x, y) if the absolute value of the sum of the coordinates is less than or equal to the y-coordinate. This is because the maximum distance Monocarp can travel in one second is 1 unit in any direction, and the coin falls down by 1 unit each second.
- **Buggy Code Condition**: The condition `if(x < y)` is incorrect because it does not account for the absolute values and the sum of the coordinates.

### Test Case Generation:
To expose the bug, we need a test case where the coordinates (x, y) do not satisfy `x < y` but Monocarp can still collect the coin. Here are some examples:
- **Example 1**: (1, 1) - Monocarp can move to (1, 1) in one second.
- **Example 2**: (-1, 1) - Monocarp can move to (-1, 1) in one second.
- **Example 3**: (1, -1) - Monocarp cannot collect this coin because it falls off the screen before he can reach it.
- **Example 4**: (-1, -1) - Monocarp cannot collect this coin because it falls off the screen before he can reach it.

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

### Explanation:
- **(1, 1)**: Monocarp can move to (1, 1) in one second, so the output should be "YES".
- **(-1, 1)**: Monocarp can move to (-1, 1) in one second, so the output should be "YES".
- **(1, -1)**: The coin falls off the screen before Monocarp can reach it, so the output should be "NO".
- **(-1, -1)**: The coin falls off the screen before Monocarp can reach it, so the output should be "NO".

This test input will expose the bug in the condition `if(x < y)` and show that the code is not correctly determining whether Monocarp can collect the coin.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
#include<bits/stdc++.h>
using namespace std;
#define faster ios_base::sync_with_stdio(false);cin.tie(NULL)
#define ll long long
#define ull unsigned long long
#define pi acos(-1)
#define yes "YES"
#define no "NO"
#define endl "\n"
#define MAX INT_MAX
#define MIN INT_MIN
#define pow2(n) n&(n-1)
#define lcm(a,b) (a*b)/__gcd(a,b)
#define pii pair<int,int>
#define pll pair<long long ,long long>
#define setpre(n) fixed<<setprecision(n)
#define struct node Node
#define forn(n) for(int i=0;i<n;i++)
#define asort(v) sort(v.begin(),v.end())
#define dsort(v) sort(v.rbegin(),v.rend())
#define vecinp(v,n) for(int i=0;i<n;i++) cin>>v[i]
#define revs(v) reverse(v.begin(),v.end())
#define mem(a,b) memset(a,b,sizeof(a))
#define test() int t;cin>>t;while(t--)
#define nesloop(n,m) for(int i=0;i<n;i++) for(int j=0;j<m;j++)
int const N=1e5;
int mod=1e7;
//........................................................................................................
//........................................................................................................
bool isprime(int n){
	if (n == 1) return false;
	for (int i=2; i*i<=n;i++)
		if(n%i==0) return false;
	return true;
}
vector<int>sieve(int n){
    vector<bool>prime(n+1,true);
    for(int i=2;i<=sqrt(n);i++){
        if(prime[i])
            for(int j=i*i;j<=n;j+=i) prime[j]=false;
    }
    prime[0]=prime[1]=false;
    vector<int>primes;
    for(int i=2;i<=n;i++)
        if(prime[i]) primes.push_back(i);
    return primes;
}
vector<int>PF(int n){
    vector<int>primes=sieve(N);
    vector<int>pf;
    int fin=upper_bound(primes.begin(),primes.end(),n)-primes.begin();
    for(int i=0;i<fin;i++){
           if(n==1) break;
        while(n%primes[i]==0){
            pf.push_back(primes[i]); n/=primes[i];
        }
    }
    return pf;
}
ll BinaryMultiply(ll a,ll b){
    ll ans=0;
    while(b){
        if(b&1) ans=(ans+a)%mod; a=(a+a)%mod;
        b>>=1;
    }
    return ans;
}
ll binex(ll a,ll b){
    ll ans=1;
    while(b){
        if(b&1) ans=BinaryMultiply(ans,a); a = BinaryMultiply(a,a); b>>=1;
    }
    return ans;
}
int digitsum(int n){
    int ans=0;
    while(n) ans+=(n%10),n/=10; return ans;
}
ull summation(ull n){
    ull  sum;  if(n%2) sum=(n+1)/2,sum*=n;
    else sum=n/2,sum*=(n+1);
    return sum;
}
void solve(){
    int n; cin >>n;
    for(int i=0;i<n;i++){

        int x,y; cin>>x>>y;
        if(i==0) cout<<yes<<endl;
        else if(x>=0 && y>=0) cout<<yes<<endl;
        else if(x>y) cout<<no<<endl;
        else cout<<yes<<endl;
    }
}
//*********************************************************************************************//
int main(){
    faster;
    //test()
        solve();
return 0;
}

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

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

Think step by step.

Response:
```plaintext
5
-1 1
1 -1
-1 -1
1 1
0 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import sys
import os
import itertools
from math import ceil
input = sys.stdin.readline
mod = 10**9 + 7

# Overwrite print function
def print(*args, sep=' ', end='\n', file=sys.stdout):
    if file is sys.stdout:
        sys.stdout.write(sep.join(map(str, args)) + end)
    else:
        # Fallback for cases where the file argument is used
        builtins.print(*args, sep=sep, end=end, file=file)

# Functions for input handling
def inp():
    return int(input())

def st():
    return input().rstrip('\n')

def lis():
    return list(map(int, input().split()))

def ma():
    return map(int, input().split())

tcs=inp()
for _ in range(tcs):
    x,y=ma()
    #print(x,y)
    print("Yes" if abs(y-abs(x)+1)<=abs(x) else "NO")

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
from sys import stdin

def run(x , y):
    if y >=  -abs(x):
        print("YES")
    else:
        print("NO")

def main():
    data = []
    for line in stdin:
        data.append(line.strip())
    num_test_case = int(data[0])
    r = 1
    for _ in range(num_test_case):
        coins = [int(x) for x in data[r].split()]
        r += 1
        run(coins[0], coins[1])

if __name__ == "__main__":
    main()

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

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

Think step by step.

Response:
To expose the bug in the provided code, we need to focus on the condition `if y >= -abs(x)`. This condition is not entirely correct because it doesn't account for the fact that the character can move diagonally, which means the character can reach any point where the sum of the absolute values of the x and y coordinates is less than or equal to the number of moves.

A good test case to expose this bug would be one where the coin is positioned such that the character can reach it by moving diagonally, but the condition `if y >= -abs(x)` would incorrectly evaluate to `NO`.

Let's consider a coin at position `(1, -2)`. According to the movement rules, the character can move from `(0, 0)` to `(1, -1)` in one move. After the coin falls, it will be at `(1, -2)`, which the character can then move to in the next move. However, the condition `if y >= -abs(x)` would evaluate to `NO` because `-2 < -abs(1) = -1`.

Here is the test input that exposes the bug:

```plaintext
1
1 -2
```

This input will show that the character can actually collect the coin, but the buggy code will incorrectly output `NO`.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
import math
import bisect
from collections import Counter
from collections import defaultdict
from functools import reduce
from itertools import permutations
from itertools import combinations
from itertools import combinations_with_replacement
from itertools import product

BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
def gcd(a,b):
    if b==0:
        return a
    return gcd(b,a%b)
def sortByKeys(mp):
    return { i:mp[i] for i in sorted(mp.keys()) }
def sortByValues(mp):
    return { i:mp[i] for i in mp.values() }
def seive(n):
    prime=[True for i in range(n+1)]
    p=2
    while p*p<=n:
        if prime[p]==True:
            for i in range(p*p,n+1,p):
                prime[i]=False
        p+=1
    return [x for x in range(2,n) if prime[x]]
def isPrime(n):
    if n<=1:
        return False
    if n<=3:
        return True
    if n%2==0 or n%3==0:
        return False
    i=5
    while i*i<=n:
        if n%i==0 or n%(i+2)==0:
            return False
        i+=6
    return True
def primeFactors(n):
    factors = {}
    while n % 2 == 0:
        if 2 in factors:
            factors[2] += 1
        else:
            factors[2] = 1
        n = n // 2
    for i in range(3,int(n**0.5)+1,2):
        while n % i== 0:
            if i in factors:
                factors[i] += 1
            else:
                factors[i] = 1
            n = n // i
    if n > 2:
        factors[n] = 1
    return factors
def factors(n):
    fact = []
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            if n // i == i:
                fact.append(i)
            else:
                fact.append(i)
                fact.append(n//i)
    return fact
def zAlgorithm(text,pattern):
    ans = []
    z = pattern + "$" + text
    n = len(z)
    l,r = 0,0
    z = [0]*n
    for i in range(1,n):
        if i <= r:
            z[i] = min(r-i+1,z[i-l])
        while i + z[i] < n and z[i] + i < len(pattern) and z[i] == pattern[z[i]+i]:
            z[i] += 1
        if i + z[i] - 1 > r:
            l = i
            r = i + z[i] - 1
        if z[i] == len(pattern):
            ans.append(i-len(pattern)-1)
    return ans
def kmp(text,pattern):
    ans = []
    n = len(text)
    m = len(pattern)
    lps = [0]*m
    j = 0
    i = 1
    while i < m:
        if pattern[i] == pattern[j]:
            j += 1
            lps[i] = j
            i += 1
        else:
            if j != 0:
                j = lps[j-1]
            else:
                lps[i] = 0
                i += 1
    i = 0
    j = 0
    while i < n:
        if pattern[j] == text[i]:
            i += 1
            j += 1
        if j == m:
            ans.append(i-j)
            j = lps[j-1]
        elif i < n and pattern[j] != text[i]:
            if j != 0:
                j = lps[j-1]
            else:
                i += 1
    return ans
def segmentTree(arr):
    n = len(arr)
    tree = [0]*(4*n)
    def build(node,start,end):
        if start == end:
            tree[node] = arr[start]
        else:
            mid = (start+end)//2
            build(2*node,start,mid)
            build(2*node+1,mid+1,end)
            tree[node] = tree[2*node] + tree[2*node+1]
    def update(node,start,end,idx,val):
        if start == end:
            arr[idx] = val
            tree[node] = val
        else:
            mid = (start+end)//2
            if start <= idx <= mid:
                update(2*node,start,mid,idx,val)
            else:
                update(2*node+1,mid+1,end,idx,val)
            tree[node] = tree[2*node] + tree[2*node+1]
    def query(node,start,end,l,r):
        if r < start or end < l:
            return 0
        if l <= start and end <= r:
            return tree[node]
        mid = (start+end)//2
        p1 = query(2*node,start,mid,l,r)
        p2 = query(2*node+1,mid+1,end,l,r)
        return p1 + p2
    build(1,0,n-1)
    return [build,update,query]
def binarySearch(arr,x):
    l,r = 0,len(arr)-1
    while l <= r:
        mid = (l+r)//2
        if arr[mid] == x:
            return mid
        elif arr[mid] < x:
            l = mid + 1
        else:
            r = mid - 1
    return -1
def isPalindrome(s):
    return s == s[::-1]
def isVowel(ch):
    return ch in ['A','E','I','O','U','a','e','i','o','u']
def isConsonant(ch):
    return not isVowel(ch)
def isPowerOfTwo(n):
    return (n & (n-1)) == 0
def isPerfectSquare(n):
    return n**0.5 == int(n**0.5)
def isPerfectCube(n):
    return n**(1/3) == int(n**(1/3))
def upperBound(arr,x):
    l,r = 0,len(arr)
    while l < r:
        mid = (l+r)//2
        if arr[mid] <= x:
            l = mid + 1
        else:
            r = mid
    return l
def lowerBound(arr,x):
    l,r = 0,len(arr)
    while l < r:
        mid = (l+r)//2
        if arr[mid] < x:
            l = mid + 1
        else:
            r = mid
    return l
def solve():
    x,y=map(int,input().split())
    # arr=list(map(int,input().split()))
    val=y-abs(x)+1
    # print(val,'val')
    x=abs(x)
    if val<=x and val>=-x:
        return 'YES'
    return 'NO'
for _ in range(int(input())):
    print(solve())

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to focus on edge cases that are likely to cause issues. The code provided seems to be checking if the character can reach a coin based on its initial position. The key logic is in the `solve` function, which calculates the value `val = y - abs(x) + 1` and checks if this value is within the range `[-x, x]`.

Let's consider the following scenarios:
1. **Coins on the same vertical line as the character (x = 0)**: This can expose issues with the logic if the code incorrectly handles the vertical movement.
2. **Coins on the same horizontal line as the character (y = 0)**: This can expose issues with the logic if the code incorrectly handles the horizontal movement.
3. **Coins with extreme values (close to the boundaries of the coordinate limits)**: This can expose issues with the logic if the code does not handle large or small values correctly.
4. **Coins that fall just out of reach**: This can expose issues with the logic if the code does not correctly account for the falling coins.

Given these considerations, let's construct a small-scale test input that includes these edge cases:

```plaintext
4
0 1
1 0
-50 50
-1 -1
```

### Explanation:
1. **Coin at (0, 1)**: This coin is directly above the character. The character can move up to (0, 1) and collect the coin.
2. **Coin at (1, 0)**: This coin is directly to the right of the character. The character can move right to (1, 0) and collect the coin.
3. **Coin at (-50, 50)**: This coin is at the extreme boundary. The character should be able to reach this coin by moving diagonally up and to the left.
4. **Coin at (-1, -1)**: This coin is diagonally down and to the left of the character. The character can move to (-1, -1) and collect the coin.

This test input should help expose any bugs in the logic of the provided code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] coins = new int[n][2];
        for (int i = 0; i < n; i++) {
            coins[i][0] = scanner.nextInt();
            coins[i][1] = scanner.nextInt();
        }
        for (int i = 0; i < n; i++) {
            int x = coins[i][0];
            int y = coins[i][1];
            if(x<=0 && y<=0 && y<x){
                System.out.println("NO");
            }else{
                System.out.println("YES");
            }
        }
    }
}

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

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

Think step by step.

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

### Explanation:
1. **Coin at (-1, -1)**:
   - Monocarp can move from (0, 0) to (-1, -1) in one move.
   - The coin will then fall to (-1, -2), and Monocarp can move to (-1, -2) in the next move.
   - **Expected Output: YES**

2. **Coin at (-2, -2)**:
   - Monocarp can move from (0, 0) to (-1, -1) in one move.
   - The coin will then fall to (-2, -3), and Monocarp can move to (-2, -3) in the next move.
   - **Expected Output: YES**

3. **Coin at (-3, -3)**:
   - Monocarp can move from (0, 0) to (-1, -1) in one move.
   - The coin will then fall to (-3, -4), and Monocarp can move to (-3, -4) in the next move.
   - **Expected Output: YES**

The buggy code incorrectly prints "NO" for the second and third coins because it checks `y < x` and both conditions are true for these coins. This test input exposes the bug in the condition `if(x <= 0 && y <= 0 && y < x)`.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        CanGetTheCoin();
    }
    public static void CanGetTheCoin( ){
        Scanner input=new Scanner(System.in);

        int t=input.nextInt();
        for (int i = 0; i <t ; i++) {
            int x=input.nextInt() ;
            int y =input.nextInt();
            int XLocation=0;int YLocation=0;
            if (YLocation<=y) {
                System.out.println("YES");
            }
            else if (Math.abs(XLocation-x)>0&&Math.abs(YLocation-y)==1)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }
    }

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

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

Think step by step.

Response:
```plaintext
3
1 1
-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: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

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

void IOS()
{
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}

#define inarr(a, n)   for (ll i = 0; i < n; i++) cin >> a[i];
#define outarr(a, n) for (ll i = 0; i < n; i++) cout << a[i] << " "; cout << endl;
#define fr(i, s, e) for (ll i = s; i < e; i++)
#define rf(i, s, e) for (ll i = s - 1; i >= e; i--)
#define pb push_back
#define ff first
#define ss second
#define all(v) v.begin(), v.end()
#define sz(v) (ll)(v.size())
#define nl endl
#define to_lower(s1) transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
#define to_upper(s1) transform(s1.begin(), s1.end(), s1.begin(), ::toupper);

typedef long long int ll; // only int (hide typedef & define ll int);  only ll (define int ll)
typedef long double lld;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<pll> vpll;

const ll MOD = 1e9 + 7;
const ll inf = 1e18;
const ll N = 1e3 + 5;

void sol()
{
    ll n;cin>>n;
    vpll c;
    ll mini = INT_MAX;
    for(ll i=0 ; i<n ; i++)
    {
        ll x,y;
        cin>>x>>y;
        c.pb({x,y});
        if(mini==INT_MAX and y<0)
        {
            mini = y;
        }

    }

    for(auto it:c)
    {
        ll x = it.ff;
        ll y = it.ss;

        if(y>=mini)cout<<"YES"<<nl;
        else cout<<"NO"<<nl;
    }

}

int main()
{
    IOS();
    ll t = 1;
    // cin >> t;
    while (t--)
    {
        sol();
    }
    return 0;
}

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided code, let's analyze the code and identify the potential issues:

1. **Bug in `mini` Initialization**: The variable `mini` is initialized to `INT_MAX` and is only updated if `y < 0`. This means if there are no coins with negative `y` values, `mini` will remain `INT_MAX`, which can lead to incorrect results.

2. **Incorrect Condition for `YES`**: The condition `if(y >= mini)` is used to determine if a coin can be collected. This condition is flawed because it does not consider the movement capabilities of the character and the falling of the coins.

To expose these issues, we can create a test case with the following characteristics:
- Include coins with both positive and negative `y` values.
- Ensure that some coins are not reachable even though their `y` value is greater than or equal to the smallest negative `y` value.

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

```plaintext
4
1 1
1 -1
-1 1
-1 -1
```

### Explanation:
- **Coin at (1, 1)**: This coin is not reachable because the character cannot move to (1, 1) in one move from (0, 0).
- **Coin at (1, -1)**: This coin is reachable in one move from (0, 0) to (1, -1).
- **Coin at (-1, 1)**: This coin is not reachable because the character cannot move to (-1, 1) in one move from (0, 0).
- **Coin at (-1, -1)**: This coin is reachable in one move from (0, 0) to (-1, -1).

This test case will help expose the bug because the code will incorrectly determine that the coins at (1, 1) and (-1, 1) can be collected, even though they cannot be reached in one move.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

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

auto init = []() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    return 'c';
}();

// Types name...........................
typedef long long ll;
typedef long l;
typedef double d;

typedef pair<int,int> pi;
typedef pair<long,long> pl;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int,int>> vpi;
typedef vector<pair<long,long>> vpl;

// Macros.................................
#define F first
#define S second
#define PB push_back
#define MK make_pair

//Shorten loops...............................
#define TRA(i,a,b) for(int i=a;i<b;i++)

ll mod =1e9+7;

void solve(){

      int x,y;
      cin>>x>>y;

      if(x == 0){
        cout<<"NO"<<endl;
        return;
      }else if( y == 0){
        cout<<"YES"<<endl;
        return;
      }

      if( y > 0){
        if( x > y) cout<<"NO"<<endl;
        else cout<<"YES"<<endl;
        return;
      }
      if( y < 0){
          if( x > y) cout<<"NO"<<endl;
           else cout<<"YES"<<endl;
           return;
      }
}

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

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

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

Think step by step.

Response:
```plaintext
3
-1 0
0 1
1 -1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
for i in range(int(input())):
    x, y = map(int, input().split())
    if y < x and y < 0 :
        print("NO")
    else:
        print("YES")

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the given buggy code, we need to focus on edge cases where the character's movement and the coin's falling behavior interact in non-trivial ways. Specifically, we need to create a scenario where the coin's position and the character's movement capabilities are such that the character cannot collect the coin, despite the coin being within a seemingly reachable distance.

The buggy code has a condition that checks if `y < x` and `y < 0`, and if both conditions are true, it prints "NO". This condition is incorrect because it doesn't fully capture the scenarios where the character cannot collect the coin. For example, the character can move diagonally, and the coin can fall down, which can change the relative positions.

Let's consider the following test case:

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

### Explanation:
1. **Coin at (1, -1):**
   - The character can move to (1, -1) in one step.
   - However, the coin falls to (1, -2) before the character can collect it.
   - The character cannot reach (1, -2) in one step from (0, 0).

2. **Coin at (-1, 1):**
   - The character can move to (-1, 1) in one step.
   - The coin falls to (-1, 0) before the character can collect it.
   - The character can then move to (-1, 0) and collect the coin.

3. **Coin at (-2, -1):**
   - The character cannot move to (-2, -1) in one step.
   - The coin falls to (-2, -2) before the character can collect it.
   - The character cannot reach (-2, -2) in one step from (0, 0).

### Expected Output:
```plaintext
NO
YES
NO
```

This test case will expose the bug in the code because the condition `y < x and y < 0` does not correctly handle the scenarios where the coin's falling behavior affects the character's ability to collect the coin.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

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

t = int(input())

for _ in range(t):
    x,y = map(int, input().split())
    if -abs(x) <= y:
        print("YES")
    else:
        print("NO")

**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 where the code might fail. The bug in the code is that it only checks if the y-coordinate is greater than or equal to the negative of the absolute value of the x-coordinate, which is not sufficient to determine if Monocarp can collect the coin.

Let's consider the following scenarios:
1. Coins that are initially out of reach but can be collected after falling.
2. Coins that are initially within reach but cannot be collected due to the fall.
3. Coins that are exactly on the boundary of the movement range.

Here is a small-scale test input that covers these scenarios:

```plaintext
5
1 1
-1 -1
1 -2
-2 1
0 50
```

Explanation:
1. `(1, 1)`: This coin is initially within reach and can be collected.
2. `(-1, -1)`: This coin is initially within reach and can be collected.
3. `(1, -2)`: This coin is initially out of reach but can be collected after falling.
4. `(-2, 1)`: This coin is initially within reach but cannot be collected due to the fall.
5. `(0, 50)`: This coin is initially out of reach and cannot be collected.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int tc=scn.nextInt();
        while(tc-->0){
            int x=scn.nextInt();
            int y=scn.nextInt();
            int i=0;
           boolean flag=false;
            while(y-i>=-50 &&y-i<=50){
                if(f(x,y-i)){
                    flag=true;
                    break;

                }
                i++;
            }
            if(flag){
                System.out.println("YES");
            }else{
                System.out.println("NO");
            }

        }

    }

    public static boolean f(int x,int y ){

        if(Math.abs(x)>=50 || Math.abs(y)>=50) return false;
        else if(x==0 || y==0) return true;
        else if(Math.abs(y/x)==1) return true;
        return false;

    }
}

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.*;
public class coin{
    public static void main(String[] arg){
        Scanner inp=new Scanner(System.in);
        int no=inp.nextInt();
        String s="Yes";
        String n="No";
        for(int i=0;i<no;i++){
            int x=inp.nextInt();
            int y=inp.nextInt();
            if(x>=0 && y>=0)System.out.println(s);
            else if(x<0 && y>-2)System.out.println(s);
            else System.out.println(n);
        }
    }
}

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

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

//*********HILAOOOOOOOOOOO*********/

//Modular arithmetic: (a-b)%m=a%m-b%m+m

//**************Binary exponentiation*************//
/*
int mod=1e9+7;
ll power(ll a, ll b) {
    a %= mod;
    ll ans = 1;
    while (b > 0) {
        if (b & 1)  ans= ans * a % mod;
        b >>= 1;
        a =a*a % mod;
    }
    return ans;
}
*/

/***************DEBUG******************/
/*
a)SEGV:
 1.check out of bonds before every inc/dec variables/ptrs
 2.PRINTING SOMETHING BEFORE TAKING ALL INPUTS

 ->Check LONG LONG (FOR ALL VARIABLES)
 ->Cout/flag daalke dekh independently
 ->Logic upar niche(before/after)
 ->any CONDITIONAL error/ wrong DIVISION (by 0)
*/
void solve()
{
  //IF UNABLE TO SOLVE: BIAS HATAO, RE-READ and INTERPRET(analyze each step/assumption carefully and slowly)
  int n;
  cin>>n;
  vector<pair<int,int>> a(n);
  for(int i=0;i<n;i++)
  {
    cin>>a[i].first>>a[i].second;
  }
  for(int i=0;i<n;i++)
  {
    int x=(a[i].first);
    int y=(a[i].second);
    if((y-abs(x))<=abs(x)+1&& y>=-1) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
  }
}

int main() {
  ios_base::sync_with_stdio(false); //turning off backward compatibilty to C
  cin.tie(NULL);
  cout.tie(NULL);
  // int t;
  // cin >> t;
  // while (t--)
  // {
  //   //new STL: count(a.begin(), a.end(), element) how many times it appears
  //   solve();
  // }
  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
5
-1 1
1 1
-2 2
2 2
0 2
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
// Problem: A. Catch the Coin
// Contest: Codeforces - Educational Codeforces Round 167 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1989/problem/0
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)

/*
                       _oo0oo_
                      o8888888o
                      88" . "88
                      (| -_- |)
                      0\  =  /0
                    ___/`---'\___
                  .' \|     |// '.
                 / \|||  :  |||// \
                / _||||| -:- |||||- \
               |   | \  -  /// |   |
               | \_|  ''\---/''  |_/ |
               \  .-\__  '-'  ___/-. /
             ___'. .'  /--.--\  `. .'___
          ."" '<  `.___\_<|>_/___.' >' "".
         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
         \  \ `_.   \_ __\ /__ _/   .-` /  /
     =====`-.____`.___ \_____/___.-`___.-'=====
                       '=---='

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main(){
	int n;
	cin>>n;
	while(n--){
		int x,y;
		cin>>x>>y;
		if(y>0){
			int sum=x;
			if(sum<0)sum*=-1;
			int res=y-sum;
			if(res<0)res*=-1;
			if(res<sum)cout<<"YES\n";
			else cout<<"NO\n";
		}else if(y==0){
			cout<<"YES\n";
		}else {
			int sum=x,num=y;
			if(sum<0)sum*=-1;
			if(num<0)num*=-1;
			if(sum>num)cout<<"YES\n";
			else cout<<"NO\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
5
-1 1
1 -1
2 2
-2 -2
0 1
```


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
n=int(input())
arr=[]
for i in range(n):
    x,y=list(map(int,input().split()))
    diff = abs(x)-abs(y)
    diff=abs(diff)
    if x==0:
        if y>=-1:
            print("YES")
        else:
            print("NO")
        continue
    if y>=0:
        print("YES")
        continue

    if y<0:
        time = abs(x)-abs(y)
        if abs(y)>abs(x):
            print("NO")
            continue
        if abs(time)<=abs(abs(x)-1):
            print("YES")
        else:
            print("NO")

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to focus on edge cases that the code might handle incorrectly. Here are the key points to consider:

1. **Coins at the same horizontal level as the character (y = 0)**: The code seems to handle this case correctly, so we don't need to focus on this too much.
2. **Coins below the character (y < 0)**: The code has a complex logic to determine if the coin can be collected. We need to test this logic thoroughly.
3. **Coins with the same absolute x and y values**: The code might have issues with these cases.
4. **Coins with different absolute x and y values**: We need to ensure the code correctly calculates the time and distance.

Let's create a test input that includes these scenarios:

```plaintext
5
-1 -1
1 -1
-2 -2
2 -2
0 -1
```

Explanation:
- The first coin is at (-1, -1). Monocarp can move to (-1, -1) in one step, and the coin will fall to (-1, -2), so Monocarp can collect it.
- The second coin is at (1, -1). Monocarp can move to (1, -1) in one step, and the coin will fall to (1, -2), so Monocarp can collect it.
- The third coin is at (-2, -2). Monocarp can move to (-1, -1) in one step, and the coin will fall to (-2, -3), so Monocarp can collect it.
- The fourth coin is at (2, -2). Monocarp can move to (1, -1) in one step, and the coin will fall to (2, -3), so Monocarp can collect it.
- The fifth coin is at (0, -1). Monocarp can move to (0, -1) in one step, and the coin will fall to (0, -2), so Monocarp can collect it.

This test input should expose the bugs in the provided code, especially in the logic for handling coins below the character.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
for _ in range(int(input())):
  x,y=map(int,input().split())
  if x>0 and y<=0:
    print("YES")
  elif x<y:
    print("YES")
  else:
    print("NO")

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

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

Think step by step.

Response:
To expose the bug in the given buggy code, we need to focus on edge cases where the conditions in the code might fail. The code has the following logic:

1. If `x > 0` and `y <= 0`, it prints "YES".
2. If `x < y`, it prints "YES".
3. Otherwise, it prints "NO".

We need to find a test case where the conditions in the code do not correctly determine whether Monocarp can collect the coin.

### Step-by-Step Analysis:

1. **Case 1: `x > 0` and `y <= 0`**
   - This condition is correct for some cases but not all. For example, if `x = 1` and `y = -1`, Monocarp can move to (1, -1) and collect the coin. However, if `x = 1` and `y = -2`, the coin will fall to (1, -3) before Monocarp can reach it.

2. **Case 2: `x < y`**
   - This condition is also correct for some cases but not all. For example, if `x = -1` and `y = 1`, Monocarp can move to (-1, 1) and collect the coin. However, if `x = -2` and `y = 1`, the coin will fall to (-2, 0) before Monocarp can reach it.

3. **Case 3: All other cases**
   - This condition is incorrect for some cases. For example, if `x = 1` and `y = 1`, Monocarp can move to (1, 1) and collect the coin, but the code will print "NO".

### Challenging Test Input:

To expose the bug, we can create a test case where `x` and `y` are close to each other but the conditions in the code fail to correctly determine the result.

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

### Explanation:

1. **Coin at (1, 1)**
   - Monocarp can move to (1, 1) and collect the coin. The code will incorrectly print "NO" because it does not handle the case where `x == y`.

2. **Coin at (1, -2)**
   - Monocarp can move to (1, -1) and then to (1, -2) after the coin falls. The code will correctly print "YES" because it satisfies the condition `x > 0` and `y <= 0`.

3. **Coin at (-2, 1)**
   - Monocarp can move to (-1, 1) and then to (-2, 1) after the coin falls. The code will incorrectly print "NO" because it does not handle the case where `x < y` but the coin falls to a position Monocarp can reach.

This test input will expose the bug in the given code by providing cases where the conditions fail to correctly determine whether Monocarp can collect the coin.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.Scanner;

public class ProblemA {
    public static void main (String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        int[][] a = new int[n][2];

        for (int i = 0; i < n; i++) {
            a[i][0] = in.nextInt();
            a[i][1] = in.nextInt();

            if (a[i][1] > 0)
                System.out.println("Yes");
            else {
                if (Math.abs(a[i][0]) > Math.abs(a[i][1]))
                    System.out.println("Yes");
                else
                    System.out.println("No");
            }
        }
    }
}

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

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

Think step by step.

Response:
To expose the bug in the given buggy code, we need to create a test case that highlights the issue with the logic. The buggy code incorrectly determines whether Monocarp can collect a coin based on the conditions:

1. If the coin's y-coordinate is greater than 0, it prints "Yes".
2. If the coin's y-coordinate is less than or equal to 0 and the absolute value of the x-coordinate is greater than the absolute value of the y-coordinate, it prints "Yes".
3. Otherwise, it prints "No".

This logic fails to correctly handle cases where the coin can be collected despite the conditions not being met. Specifically, it does not account for the fact that the coin falls down by 1 each second, and Monocarp can move diagonally.

Let's create a test case that includes coins where the y-coordinate is less than or equal to 0 and the absolute value of the x-coordinate is less than or equal to the absolute value of the y-coordinate, but Monocarp can still collect the coin by moving diagonally.

### Test Input
```plaintext
5
1 -1
-1 1
2 -2
-2 2
3 -3
```

### Explanation
1. **Coin at (1, -1)**:
   - Monocarp can move from (0, 0) to (1, -1) in one second, and the coin will fall to (1, -2). Monocarp can then move to (1, -2) and collect the coin.
   - Expected output: "YES"

2. **Coin at (-1, 1)**:
   - Monocarp can move from (0, 0) to (-1, 1) in one second, and the coin will fall to (-1, 0). Monocarp can then move to (-1, 0) and collect the coin.
   - Expected output: "YES"

3. **Coin at (2, -2)**:
   - Monocarp can move from (0, 0) to (1, -1) in one second, and the coin will fall to (2, -3). Monocarp can then move to (2, -2) and collect the coin.
   - Expected output: "YES"

4. **Coin at (-2, 2)**:
   - Monocarp can move from (0, 0) to (-1, 1) in one second, and the coin will fall to (-2, 1). Monocarp can then move to (-2, 2) and collect the coin.
   - Expected output: "YES"

5. **Coin at (3, -3)**:
   - Monocarp can move from (0, 0) to (1, -1) in one second, and the coin will fall to (3, -4). Monocarp can then move to (2, -2) and collect the coin.
   - Expected output: "YES"

This test case will expose the bug in the buggy code, as it will incorrectly print "No" for all these coins, while the correct output should be "YES" for all of them.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Catch the Coin
time_limit_ms: 2000
memory_limit_mb: 256
Description: Monocarp visited a retro arcade club with arcade cabinets. There got curious about the "Catch the Coin" cabinet.

The game is pretty simple. The screen represents a coordinate grid such that:

  * the X-axis is directed from left to right;    * the Y-axis is directed from bottom to top;    * the center of the screen has coordinates $(0, 0)$.

At the beginning of the game, the character is located in the center, and $n$ coins appear on the screen — the $i$-th coin is at coordinates $(x_i, y_i)$. The coordinates of all coins are different and not equal to $(0, 0)$.

In one second, Monocarp can move the character in one of eight directions. If the character is at coordinates $(x, y)$, then it can end up at any of the coordinates $(x, y + 1)$, $(x + 1, y + 1)$, $(x + 1, y)$, $(x + 1, y - 1)$, $(x, y - 1)$, $(x - 1, y - 1)$, $(x - 1, y)$, $(x - 1, y + 1)$.

If the character ends up at the coordinates with a coin, then Monocarp collects that coin.

After Monocarp makes a move, all coins fall down by $1$, that is, they move from $(x, y)$ to $(x, y - 1)$. You can assume that the game field is infinite in all directions.

Monocarp wants to collect at least one coin, but cannot decide which coin to go for. Help him determine, for each coin, whether he can collect it.

Input: The first line contains a single integer $n$ ($1 \le n \le 500$) — the number of coins.

In the $i$-th of the next $n$ lines, two integers $x_i$ and $y_i$ ($-50 \le x_i, y_i \le 50$) are written — the coordinates of the $i$-th coin. The coordinates of all coins are different. No coin is located at $(0, 0)$.

Output: For each coin, print "YES" if Monocarp can collect it. Otherwise, print "NO".

Examples:
input:
5
24 42
-2 -1
-1 -2
0 -50
15 0
output:
YES
YES
NO
NO
YES

Note: Pay attention to the second coin in the example. Monocarp can first move from $(0, 0)$ to $(-1, -1)$. Then the coin falls $1$ down and ends up at $(-2, -2)$. Finally, Monocarp moves to $(-2, -2)$ and collects the coin.

Buggy Code:
import java.util.*;

public class SG{
    public static void main(String[] args){
        Scanner scanner =new Scanner(System.in);
        int t = scanner.nextInt();
        while(t-->0){
            int x =scanner.nextInt();
            int y =scanner.nextInt();

            if(y == 0){
                System.out.println("YES");
            }else if(y-x>=0){
                System.out.println("YES");
            }else{
                System.out.println("NO");
            }
        }

        }
        // scanner.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
-1 1
1 -1
0 1
```