Connected Component on a Chessboard（CF-1196E）

Problem Description

You are given two integers bb and ww. You have a chessboard of size 109×109109×109 with the top left cell at (1;1)(1;1), the cell (1;1) is painted white.

Your task is to find a connected component on this chessboard that contains exactly bb black cells and exactly ww white cells. Two cells are called connected if they share a side (i.e. for the cell (x,y) there are at most four connected cells: (x−1,y),(x+1,y),(x,y−1),(x,y+1)). A set of cells is called a connected component if for every pair of cells C1 and C2 from this set, there exists a sequence of cells c1, c2, ..., ck such that c1=C1, ck=C2, all cici from 11 to kk are belong to this set of cells and for every i∈[1,k−1], cells cici and ci+1ci+1 are connected.

Obviously, it can be impossible to find such component. In this case print "NO". Otherwise, print "YES" and any suitable connected component.

You have to answer qq independent queries.

Input

The first line of the input contains one integer q (1≤q≤105) — the number of queries. Then qq queries follow.

The only line of the query contains two integers b and w (1≤b,w≤105) — the number of black cells required and the number of white cells required.

It is guaranteed that the sum of numbers of cells does not exceed 2⋅105 (∑w+∑b≤2⋅105).

Output

For each query, print the answer to it.

If it is impossible to find the required component, print "NO" on the first line.

Otherwise, print "YES" on the first line. In the next b+wb+w lines print coordinates of cells of your component in any order. There should be exactly bb black cells and ww white cells in your answer. The printed component should be connected.

If there are several answers, you can print any. All coordinates in the answer should be in the range [1;109].

Examples

Input

3
1 1
1 4
2 5

Output

YES
2 2
1 2
YES
2 3
1 3
3 3
2 2
2 4
YES
2 3
2 4
2 5
1 3
1 5
3 3
3 5

题意：q 组询问，每组给出 n 个黑块 m 个白块，现在有一个起点 (1,1) 为白色的黑白交叉的棋盘，现在要在这个棋盘上将 n 个黑块和 m 个白块放置在其上，使得这 n+m 个块的颜色与棋盘颜色相同而且连通，如果能放置成功，输出 YES 并任意输出一种放置方案，如果不能放置输出 NO

思路：

1 个黑块最多能连通 4 个白块，2 个黑块最多能连通 7 个白块，3 个黑块最多能连通 10 个黑块，以此类推，n 个黑块最多能连通 3*m+1 个白块，反之同理，m 个白块最多能连通 3*n+1 个黑块，因此当 n、m 的关系不满足上述结论时，输出 NO 即可

由于棋盘的空间最大能到 1E9，黑白块个数和不超过 2E5 且黑白块的位置可以随意放置，因此可以一个点为基准，向下依次放置黑白块

考虑 n、m 的大小，有三种情况：

n=m 时，以任意点为起点，依次向下顺序排列即可

n>m 时：需要以白块为基准，从上到下依次放置 m 个白块 m 个黑块，剩下 sub=n-m 个黑块，若 sub 为偶数时，从上到下依次放置到之前的 2m 块棋盘两端，若 sub 为奇数时，需要将多余的一个黑块放置在一白块的两端

n<m 时：需要以黑块为基准，从上到下依次放置 n 个白块 n 个黑块，剩下 sub=m-n 个黑块，若 sub 为偶数时，从上到下依次放置到之前的 2n 块棋盘两端，若 sub 为奇数时，需要将多余的一个白块放置在一黑块的两端

需要注意的是，当 n=3*m+1 或 m=3*n+1 时，说明 n 个黑块或 m 个白块周围已经被放满，此时最上面的一个格子同样需要放置

​​​​​​​

Source Program

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#define EPS 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
const int MOD = 1E9+7;
const int N = 500000+5;
const int dx[] = {-1,1,0,0,-1,-1,1,1};
const int dy[] = {0,0,-1,1,-1,1,-1,1};
using namespace std;
char str[N];
char t[N];
int a[N];
int sum[N];
int main(){
    int q;
    scanf("%d",&q);
    while(q--){
        int n,m;
        scanf("%d%d",&n,&m);

        if(m>3*n+1||n>3*m+1)
            printf("NO\n");
        else{
            printf("YES\n");
            if(n==m){
                for(int i=2;i<=2*n+1;i++)
                    printf("2 %d\n",i);
            }
            else if(n>m){
                int sub=n-m;

                if(n==3*m+1){
                    sub--;
                    printf("2 1\n");
                }

                for(int i=2;i<=2*m+1;i++)
                    printf("2 %d\n",i);

                int i=1;
                while(sub>1){
                    int temp=2*i;
                    printf("1 %d\n",temp);
                    printf("3 %d\n",temp);
                    sub-=2;
                    i++;
                }
                if(sub==1)
                    printf("1 %d\n",2*i);
            }
            else if(n<m){
                int sub=m-n;
                if(m==3*n+1){
                    sub--;
                    printf("3 1\n");
                }

                for(int i=2;i<=2*n+1;i++)
                    printf("3 %d\n",i);

                int i=1;
                while(sub>1){
                    int temp=2*i;
                    printf("2 %d\n",temp);
                    printf("4 %d\n",temp);
                    sub-=2;
                    i++;
                }
                if(sub==1)
                    printf("2 %d\n",2*i);
            }
        }
    }
    return 0;
}