During his last MindCoding Round, Bob encountered the following problem:

Given an empty set, implement a data structure that supports the following operations:

- addsinsert(val)to the set; if it already exists, nothing is done.val- removeserase(val)from the set; if it doesn't exist, nothing is done.val- printsfind(val)ifYESis in the set,valotherwise.NO## Input

The first line of input contains

, the number of queries.N

The followinglines contain two integers each:Nandtype, wherevalcan betype,1or2.3## Output

The output should contain the result of each type

operation, on different lines.3## Constraints

1 < N ≤ 1000 ≤ val ≤ 10^{18}

Bob knows his hash tables rather well, so he came up with this solution quickly:

1 #include <bits/stdc++.h> 2 using namespace std; 3 4 const long long MOD1 = ???; 5 const long long MOD2 = ???; 6 7 int N; 8 long long type, val; 9 map <pair <long long, long long>, bool> M; 10 11 int main() { 12 cin>>N; 13 14 while(N--) { 15 cin>>type>>val; 16 17 auto hash = make_pair(val % MOD1, val % MOD2); 18 19 if(type == 1) 20 M[hash] = true; 21 if(type == 2) 22 M[hash] = false; 23 24 if(type == 3) { 25 if(M.find(hash) == M.end() || (M.find(hash) != M.end() && !M[hash])) 26 cout<<"NO\n"; 27 else 28 cout<<"YES\n"; 29 } 30 } 31 32 return 0; 33 }

To his suprise, this solution failed pretests. Bob even tried to tinker with the values of ** MOD1** and

**, hoping that was the cause of his failure. Now he insists that his solution is correct, and the pretests are flawed. As his friend, you offer to generate a testcase that proves his solution is wrong, before he starts threatening Comisia.**

`MOD2`### Input

Two space separated values: the values of ** MOD1** and

**that Bob used.**

`MOD2`### Output

A valid testcase for the given problem, on which Bob's output is incorrect.

### Constraints

`1 ≤ MOD1, MOD2 ≤ 10`^{6}

### Sample

Input | Output | Correct answer | Bob's answer | Explanation |
---|---|---|---|---|

2 4 | 31 20 1 17 3 4 | NO | YES | After the first two operations, the set contains values 17 and 20.The third operation searches for 4, which is not in the set. However, Bob's solution outputs . YES |

The problem reduces to finding two values ** A** and

**such that:**

`B``A % MOD1 = B % MOD1``A % MOD2 = B % MOD2`

Any such pair constitutes a collision for the hash function. An appropriate testcase can then be generated as follows: ` `

2 1 A 3 B

Choosing ** A** and

**is not that difficult. A very simple solution is**

`B`**and**

`A = 0`**. Any positive constant can be added to these values without losing the collision property.**

`B = any common multiple of MOD1 and MOD2`