**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend()
#define fill(x,y) memset(x,y,sizeof(x))
#define dbg(x) cerr<<#x<<": "<<(x)<<" "
#define debug(x) cerr<<#x<<": "<<(x)<<endl

#define PI (ld)2*acos(0.0)
#define MOD 998244353
#define MOD2 1000000007

#define endl '\n'
#define YES cout<<"YES"<<endl;return
#define Yes cout<<"Yes"<<endl;return
#define yes cout<<"yes"<<endl;return
#define Y cout<<"YES"<<endl
#define NO cout<<"NO"<<endl;return
#define No cout<<"No"<<endl;return
#define no cout<<"no"<<endl;return
#define IPSB cout<<-1<<endl;return

const int inf=0x3f3f3f3f;
const ll infll=0x3f3f3f3f3f3f3f3fll;

const int mxn = 1000;
int n,m;
vector<int> G[mxn];

vector<int> ans1,ans2;
int color[mxn];

int flag=0;

void dfs(int vertex) {
	for (auto neighbor: G[vertex]){
		if (!color[neighbor]) {
			color[neighbor] = 3 - color[vertex];
			dfs(neighbor);
		}
		else if (color[neighbor] + color[vertex] != 3){
			flag=1;
			return;
		}
	}
}

void solve(){
	flag=0;
	fill(color,0);
	cin>>n>>m;
	int a,b;

	ans1.clear();
	ans2.clear();
	for(int i=1;i<=n;i++){
		G[i].clear();
	}

	for(int i=0;i<m;i++){
		cin>>a>>b;
		G[a].push_back(b);
		G[b].push_back(a);
	}
	dfs(1);
//	int a1=ans1.size(),a2=ans2.size();
//	for(int i=0;i<a1;i++){
//		cerr<<ans1[i]<<" ";
//	}
//	cerr<<endl;
//	for(int i=0;i<a2;i++){
//		cerr<<ans2[i]<<" ";
//	}
//	cerr<<endl;

	if(n==1){
		cout<<"Bob"<<endl<<flush;
		int u,v;
		cin>>u>>v;
		cout<<1<<" "<<u<<endl<<flush;
	}
	else{
		if(flag==1){
			cout<<"Alice"<<endl<<flush;
			for(int i=0;i<n;i++){
				cout<<"1 2"<<endl<<flush;
				int trash1,trash2;
				cin>>trash1>>trash2;
			}
		}
		else{//flag==0
			cout<<"Bob"<<endl<<flush;
			for(int i=1;i<=n;i++){
				if(color[i]==1){
					ans1.push_back(i);
				}
				else{
					ans2.push_back(i);
				}
			}
			int a1=ans1.size(),a2=ans2.size();
		//	for(int i=0;i<a1;i++){
		//		cerr<<ans1[i]<<" ";
		//	}
		//	cerr<<endl;
		//	for(int i=0;i<a2;i++){
		//		cerr<<ans2[i]<<" ";
		//	}
		//	cerr<<endl;
			int s1=0,s2=0;
			for(int i=0;i<n;i++){
				int u,v;
				cin>>u>>v;
				if(u==1 || v==1){
					if(s1<a1){
						cout<<ans1[s1]<<" "<<1;
						s1++;
					//	cerr<<" !1 "<<s1<<" "<<s2;
					}
					else{
						cout<<ans2[s2]<<" "<<(u+v-1);
						s2++;
					//	cerr<<" !2 "<<s1<<" "<<s2;
					}
				}
				else{
					if(s2<a2){
						cout<<ans2[s2]<<" "<<2;
						s2++;
					//	cerr<<" !3 "<<s1<<" "<<s2;
					}
					else{
						cout<<ans1[s1]<<" "<<(u+v-2);
						s1++;
					//	cerr<<" !4 "<<s1<<" "<<s2;
					}
				}
				cout<<endl<<flush;
			}
		}
	}
}

signed main(){
	ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	int tt=1;
	cin>>tt;
	while(tt--){
		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
2
3 2
1 2
2 3

4 3
1 2
2 3
3 4
```

**Explanation:**

1. **First Test Case (3 vertices, 2 edges):**
   - The graph is a simple path: 1 - 2 - 3.
   - This graph is connected and has no cycles.
   - Alice should be able to win by choosing colors in such a way that Bob is forced to color vertices in a way that creates an edge with the same color.

2. **Second Test Case (4 vertices, 3 edges):**
   - The graph is a simple path: 1 - 2 - 3 - 4.
   - This graph is also connected and has no cycles.
   - Bob should be able to win by carefully choosing vertices to color in a way that avoids creating edges with the same color.

These test cases are designed to challenge the algorithm's ability to handle simple paths and ensure that both players' strategies are correctly implemented. The first test case is particularly challenging for Bob, while the second test case is challenging for Alice.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

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

%:define int long long

using pint = pair<int,int>;
using vec = vector<int>;
%:define rep(...) define_loop(__VA_ARGS__, L4, L3, L2, L1)(__VA_ARGS__)
%:define per(...) define_loop(__VA_ARGS__, R4, R3, R2, R1)(__VA_ARGS__)
%:define rep_subset(i, s) for(int i=(s); i; i=(i-1)&(s))
%:define sz(x) (int)(x).size()
%:define all(x) begin(x), end(x)
%:define rall(x) x.rbegin(), x.rend()
%:define sort_unique(x) sort(all(x)); (x).erase(unique(all(x)), (x).end())
%:define pb push_back
%:define eb emplace_back
%:define mk make_pair

%:define define_loop(_1,_2,_3,_4,NAME,...) NAME
%:define L1(n) for(int i=0; i<=(n); ++i)
%:define L2(i, n) for(int i=0; i<=(n); ++i)
%:define L3(i, a, b) for(int i=(a); i<=(b); ++i)
%:define L4(i, a, b, c) for(int i=(a); i<=(b); i+=(c))
%:define R1(n) for(int i=(n); i>=0; --i)
%:define R2(i, n) for(int i=(n); i>=0; --i)
%:define R3(i, a, b) for(int i=(a); i>=(b); --i)
%:define R4(i, a, b, c) for(int i=(a); i>=(b); i-=(c))

#ifdef rrr
#include "template/debug.h"
#define IOS
#else
#define wer(...)
#define IOS cin.tie(nullptr)->sync_with_stdio(false);
#endif

const int MOD = (int)1e9+7; // 998244353;
const double PI = acos(-1.0);

bool bang = false;

void solve() {
    int n, m;
    cin >> n >> m;
    vector<vec> adj(n+1);
    rep(m-1) {
        int u, v;
        cin >> u >> v;
        adj[u].pb(v);
        adj[v].pb(u);
    }

    vec c(n+1);
    vec b[3];
    bool ok = true;
    int bad = -1;
    auto dfs = [&](auto self, int u, int col) -> void {
        c[u] = col;
        b[col].pb(u);
        for(int v : adj[u]) if(c[v] == 0) {
            if(col == 1) self(self, v, 2);
            if(col == 2) self(self, v, 1);
            if(ok == false) break;
        } else if(c[v] == c[u] && ok) {
            ok = false;
            bad = v;
            break;
        }
        if(bad != -1) {
            c[u] = 666;
        }
        if(bad == u) bad = -1;
    };

    rep(i, 1, n) if(ok && c[i] == 0) {
        dfs(dfs, i, 1);
    }
    wer(c);

    if(ok) {

        cout << "Bob" << endl;
        wer(b[1]);
        wer(b[2]);
        int tot[3]{};
        rep(n-1) {
            int x, y;
            cin >> x >> y;

            if(tot[1] != sz(b[1]) && tot[2] != sz(b[2])) {
                if(x == 1 || y == 1) {
                    cout << b[1][tot[1]++] << " 1" << endl;
                } else {
                    cout << b[2][tot[2]++] << " 2" << endl;
                }
            } else if(tot[1] == sz(b[1])) {
                if(x == 2 || y == 2) {
                    cout << b[2][tot[2]++] << " 2" << endl;
                } else {
                    cout << b[2][tot[2]++] << " 3" << endl;
                }
            } else {

               if(x == 1 || y == 1) {
                    cout << b[1][tot[1]++] << " 1" << endl;
                } else {
                    cout << b[1][tot[1]++] << " 3" << endl;
                }
            }
        }
    } else {

        cout << "Alice" << endl;
        int op = 0;
        int bad2 = 0;
        int i, x;
        rep(k, n-1) {
            if(op == 0) {
                cout << "1 2" << endl;

            } else if(op == 1) {
                if(bad == 1) cout << "2 3" << endl;
                else if(bad == 2) cout << "1 3" << endl;
                else cout << "1 2" << endl;
            } else {
                if(op == 2) bad2 = x, op++;
                assert(bad != bad2);
                cout << bad << ' ' << bad2 << endl;
            }

            cin >> i >> x;

            if(c[i] == 666 && op == 0) {
                bad = x, op++;
                for(int u : adj[i]) if(c[u] == 666) c[u] = 777;
            }
            else if((c[i] == 666 || c[i] == 777) && op == 1) {
                for(int u : adj[i]) if(c[u] == 777) {
                    c[u] = 888;
                    op++;

                } else if(c[u] == 666) {
                    c[u] = 777;
                }
            }

            c[i] = x;
        }
        if(bang) assert(op == 3);
    }

}

signed main() {
    int _T; cin >> _T;
    rep(i, 1, _T) {
        if(i == 8) bang = true;
        else bang = false;
        solve();
    }

}

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
from collections import defaultdict
from collections import deque
from sys import stdout
t = int(input())
for i in range(t):
    n , m = map(int,input().split(" "))
    adj = defaultdict(list)
    for j in range(m):
        u , v = map(int,input().split(" "))
        adj[u].append(v)
        adj[v].append(u)

    que = deque()
    que.append(1)
    dis = [0 for j in range(n+1)]
    Flag = False
    while que:
        #print(que)
        node = que.popleft()
        for nodes in adj[node]:
            if dis[nodes] == 0:
                que.append(nodes)
                dis[nodes] = node
            elif dis[node] == dis[nodes]:
                Flag = True
                break
            else:
                dis[nodes] = node
        if Flag:
            break
        #print(dis,que)
    if Flag:
        print("Alice")
        stdout.flush()
        for j in range(n):
            print(1,2)
            index , colour = map(int,input().split(" "))
            stdout.flush()
    else:
        colors = [0 for j in range(n+1)]
        print("Bob")
        stdout.flush()
        c1 , c2 = list(map(int,input().split(" ")))
        colors[1] = c1
        print(1,c1)
        stdout.flush()
        que = deque()
        que.append(1)
        while que:
            node = que.popleft()
            for nodes in adj[node]:
                if colors[nodes] == 0:
                    que.append(nodes)
                    c1 , c2 = list(map(int,input().split(" ")))
                    if colors[node] == c1:
                        colors[nodes] = c2
                    else:
                        colors[nodes] = c1
                    print(nodes,colors[nodes])
                    stdout.flush()

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
#!/usr/bin/env python3
import sys, getpass
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque

input = sys.stdin.readline  # to read input quickly

# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy

m9 = 10**9 + 7  # 998244353
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
MAXINT = sys.maxsize
e18 = 10**18 + 10

# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "htong"

# OFFLINE_TEST = False  # codechef does not allow getpass
def log(*args):
    if OFFLINE_TEST:
        print("\033[36m", *args, "\033[0m", file=sys.stderr)

# ---------------------------- template ends here ----------------------------

def query(pos):
    print("{}".format(pos), flush=True)

def query_tuple(a, b):
    print("{} {}".format(a, b), flush=True)

def is_bipartite(list_of_node_to_nodes):
    # leetcode.com/problems/is-graph-bipartite/discuss/119514/
    n, colored = len(list_of_node_to_nodes), {}
    for i in range(n):
        if i not in colored and list_of_node_to_nodes[i]:
            colored[i] = 1
            queue = collections.deque([i])
            while queue:
                cur = queue.popleft()
                for nex in list_of_node_to_nodes[cur]:
                    if nex not in colored:
                        colored[nex] = -colored[cur]
                        queue.append(nex)
                    elif colored[nex] == colored[cur]:
                        return False
    # you can obtain the 2-coloring from the `colored` as well
    return colored

# -----------------------------------------------------------------------------

# read line as an integer
# k = int(input())

# read line as a string
# srr = input().strip()

# read one line and parse each word as a string
# lst = input().split()

# read one line and parse each word as an integer
# a,b,c = list(map(int,input().split()))
# lst = list(map(int,input().split()))

for _ in range(int(input())):
    n, m = list(map(int,input().split()))
    list_of_node_to_nodes = [[] for _ in range(n)]
    for _ in range(m):
        a, b = list(map(int,input().split()))
        a -= 1
        b -= 1
        list_of_node_to_nodes[a].append(b)
        list_of_node_to_nodes[b].append(a)

    coloring = is_bipartite(list_of_node_to_nodes)

    # log(coloring)

    if coloring == False:
        query("Alice")
        for _ in range(n):
            query_tuple(1, 2)
            _, _ = list(map(int,input().split()))
        continue

    white = [i for i,x in coloring.items() if x == 1]
    black = [i for i,x in coloring.items() if x != 1]

    white_color = 1
    black_color = 2

    query("Bob")
    for _ in range(n):
        a, b = list(map(int,input().split()))

        if a == 1 or b == 1:
            if white:
                idx = white.pop()
                query_tuple(idx+1, 1)
                continue

        if a == 2 or b == 2:
            if black:
                idx = black.pop()
                query_tuple(idx+1, 2)
                continue

        if white:
            if a == 3 or b == 3:
                idx = white.pop()
                query_tuple(idx+1, 1)
                continue

        if black:
            if a == 3 or b == 3:
                idx = black.pop()
                query_tuple(idx+1, 1)
                continue

        raise

# -----------------------------------------------------------------------------

# your code here

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

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

Think step by step.

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

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
import java.util.*;

public class ColoringGame {
    static List<List<Integer>> adj;
    static int[] color;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        while (t-- > 0){
            int n = in.nextInt(), m = in.nextInt();
            adj = new ArrayList<>();
            for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
            for (int i = 0; i < m; i++){
                int u = in.nextInt()-1, v = in.nextInt()-1;
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
            color = new int[n];
            if (isPoss()){
                System.out.println("Bob");
                List<Integer> first = new ArrayList<>(), second = new ArrayList<>();
                for (int i = 0; i < n; i++){
                    if (color[i] == 1) first.add(i);
                    else second.add(i);
                }
                int ind1 = 0, ind2 = 0;
                for (int i = 0; i < n; i++){
                    int[] arr = new int[2];
                    for (int j = 0; j < 2; j++) arr[j] = in.nextInt();
                    Arrays.sort(arr);
                    if (arr[0] == 1 && arr[1] == 2){
                        if (ind1 < first.size()) System.out.println((first.get(ind1++)+1) + " " + (1));
                        else System.out.println((second.get(ind2++)+1) + " " + (2));
                    }
                    else if (arr[0] == 1 && arr[1] == 3){
                        if (ind1 < first.size()) System.out.println((first.get(ind1++)+1) + " " + (1));
                        else System.out.println((second.get(ind2++)+1) + " " + (3));
                    }
                    else{
                        if (ind2 < second.size()) System.out.println((second.get(ind2++)+1) + " " + (2));
                        else System.out.println((first.get(ind1++)+1) + " " + (3));
                    }
                    System.out.flush();
                }
            }
            else {
                System.out.println("Alice");
                for (int i = 0; i < n; i++){
                    System.out.println(1 + " " + 2);
                    System.out.flush();
                    int a = in.nextInt(), b = in.nextInt();
                }
            }
        }
    }

    public static boolean isPoss(){
        Queue<Integer> que = new LinkedList<>();
        que.add(0);
        int val = 1;
        while (!que.isEmpty()){
            int size = que.size();
            while (size-- > 0){
                int node = que.poll();
                color[node] = val;
                for (int neigh : adj.get(node)){
                    if (color[neigh] == 0) que.add(neigh);
                    else{
                        if (color[neigh] == val) return false;
                    }
                }
            }
            val *= -1;
        }
        return true;
    }
}

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
import java.util.*;

public class problemE {
  static final int MAX_N = 10005;
  public static boolean bipartite;
  public static List<List<Integer>> adj;
  public static int[] colors;

  public static void solve(Scanner sc) {
    int n = sc.nextInt(), m = sc.nextInt();
    adj = new ArrayList<>();
    for (int i = 0; i <= MAX_N; i++) {
      adj.add(new ArrayList<>());
    }
    for (int i = 1; i <= m; i++) {
      int u = sc.nextInt();
      int v = sc.nextInt();
      adj.get(u).add(v);
      adj.get(v).add(u);
    }
    bipartite = true;
    colors = new int[n + 1];
    Arrays.fill(colors, 0);
    Queue<Integer> q = new LinkedList<>();
    q.add(1);
    colors[1] = 1;
    while (!q.isEmpty()) {
      int curr = q.poll();
      for (int elem : adj.get(curr)) {
        if (colors[elem] == 0) {
          colors[elem] = 3 - colors[curr];
          q.add(elem);
        } else if (colors[elem] == colors[curr]) {
          bipartite = false;
        }
      }
    }
    if (bipartite) {
      System.out.println("Bob");
      LinkedList<Integer> l1 = new LinkedList<>(), l2 = new LinkedList<>();
      for (int i = 1; i <= n; i++) {
        if (colors[i] == 1) {
          l1.add(i);
        } else {
          l2.add(i);
        }
      }
      for (int i = 1; i <= n; i++) {
        int c1 = sc.nextInt();
        int c2 = sc.nextInt();
        if (c1 == 1 || c2 == 1 && l1.size() > 0) {
          System.out.println(l1.removeLast() + " " + 1);
        } else if (c1 == 2 || c2 == 2 && l2.size() > 0) {
          System.out.println(l2.removeLast() + " " + 2);
        } else if (l1.isEmpty() && !l2.isEmpty()) {
          int choose = c1 == 1 ? c2 : c1;
          System.out.println(l2.removeLast() + " " + choose);
        } else {
          int choose = c1 == 2 ? c2 : c1;
          System.out.println(l1.removeLast() + " " + choose);
        }
      }
    } else {
      System.out.println("Alice");
      for (int i = 1; i <= n; i++) {
        System.out.println(1 + " " + 2);
        int vertex, color;
        vertex = sc.nextInt();
        color = sc.nextInt();
      }
    }
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int tests = sc.nextInt();
    while (tests-- > 0) {
      solve(sc);
    }
  }
}

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

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

%:define int long long

using pint = pair<int,int>;
using vec = vector<int>;
%:define rep(...) define_loop(__VA_ARGS__, L4, L3, L2, L1)(__VA_ARGS__)
%:define per(...) define_loop(__VA_ARGS__, R4, R3, R2, R1)(__VA_ARGS__)
%:define rep_subset(i, s) for(int i=(s); i; i=(i-1)&(s))
%:define sz(x) (int)(x).size()
%:define all(x) begin(x), end(x)
%:define rall(x) x.rbegin(), x.rend()
%:define sort_unique(x) sort(all(x)); (x).erase(unique(all(x)), (x).end())
%:define pb push_back
%:define eb emplace_back
%:define mk make_pair

%:define define_loop(_1,_2,_3,_4,NAME,...) NAME
%:define L1(n) for(int i=0; i<=(n); ++i)
%:define L2(i, n) for(int i=0; i<=(n); ++i)
%:define L3(i, a, b) for(int i=(a); i<=(b); ++i)
%:define L4(i, a, b, c) for(int i=(a); i<=(b); i+=(c))
%:define R1(n) for(int i=(n); i>=0; --i)
%:define R2(i, n) for(int i=(n); i>=0; --i)
%:define R3(i, a, b) for(int i=(a); i>=(b); --i)
%:define R4(i, a, b, c) for(int i=(a); i>=(b); i-=(c))

#ifdef rrr
#include "template/debug.h"
#define IOS
#else
#define wer(...)
#define IOS cin.tie(nullptr)->sync_with_stdio(false);
#endif

const int MOD = (int)1e9+7; // 998244353;
const double PI = acos(-1.0);

bool bang = false;

void solve() {
    int n, m;
    cin >> n >> m;
    vector<vec> adj(n+1);
    rep(m-1) {
        int u, v;
        cin >> u >> v;
        adj[u].pb(v);
        adj[v].pb(u);
    }

    vec c(n+1);
    vec b[3];
    bool ok = true;
    int bad = -1;
    auto dfs = [&](auto self, int u, int col) -> void {
        c[u] = col;
        b[col].pb(u);
        for(int v : adj[u]) if(c[v] == 0) {
            if(col == 1) self(self, v, 2);
            if(col == 2) self(self, v, 1);
            if(ok == false) break;
        } else if(c[v] == c[u] && ok) {
            ok = false;
            bad = v;
            break;
        }
        if(bad != -1) {
            c[u] = 666;
        }
        if(bad == u) bad = -1;
    };

    rep(i, 1, n) if(ok && c[i] == 0) {
        dfs(dfs, i, 1);
    }
    wer(c);

    if(ok) {

        cout << "Bob" << endl;
        wer(b[1]);
        wer(b[2]);
        int tot[3]{};
        rep(n-1) {
            int x, y;
            cin >> x >> y;

            if(tot[1] != sz(b[1]) && tot[2] != sz(b[2])) {
                if(x == 1 || y == 1) {
                    cout << b[1][tot[1]++] << " 1" << endl;
                } else {
                    cout << b[2][tot[2]++] << " 2" << endl;
                }
            } else if(tot[1] == sz(b[1])) {
                if(x == 2 || y == 2) {
                    cout << b[2][tot[2]++] << " 2" << endl;
                } else {
                    cout << b[2][tot[2]++] << " 3" << endl;
                }
            } else {

               if(x == 1 || y == 1) {
                    cout << b[1][tot[1]++] << " 1" << endl;
                } else {
                    cout << b[1][tot[1]++] << " 3" << endl;
                }
            }
        }
    } else {

        cout << "Alice" << endl;
        int op = 0;
        int bad2 = 0;
        int i, x;

        rep(k, n-1) {
            if(op == 0) {
                cout << "1 2" << endl;

            } else if(op == 1) {

                if(bad == 1) cout << "2 3" << endl;
                else if(bad == 2) cout << "1 3" << endl;
                else cout << "1 2" << endl;
            } else {

                if(op == 2) bad2 = x, op++;
                assert(bad != bad2);
                cout << bad << ' ' << bad2 << endl;
            }

            cin >> i >> x;
            if(bang && k == 0) assert(i >= 3);
            if(c[i] == 666 && op == 0) {
                bad = x, op++;
                for(int u : adj[i]) if(c[u] == 666) c[u] = 777;
            }
            else if((c[i] == 666 || c[i] == 777) && op == 1) {
                for(int u : adj[i]) if(c[u] == 777) {
                    c[u] = 888;
                    op++;

                } else if(c[u] == 666) {
                    c[u] = 777;
                }
            }

            c[i] = x;
        }

    }

}

signed main() {
    int _T; cin >> _T;
    rep(i, 1, _T) {
        if(i == 8) bang = true;
        else bang = false;
        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 code, we need to focus on edge cases and scenarios that can break the logic. The code has a few potential issues:

1. **DFS Coloring Logic**: The DFS function might not correctly handle all cases, especially when the graph is not a simple tree or has complex structures.
2. **Bob's Strategy**: The code for Bob's strategy might not handle all possible scenarios, especially when the graph has cycles or specific edge cases.
3. **Alice's Strategy**: The code for Alice's strategy might not correctly identify the winning condition.

Given these points, let's create a test case that can expose these issues. We will use a small graph with a cycle to test the DFS logic and the strategy for both players.

### Test Case
```plaintext
1
4 4
1 2
2 3
3 4
4 1
```

### Explanation
- **Graph Structure**: This graph is a cycle with 4 vertices (1-2-3-4-1). This structure is particularly challenging because it forces both players to think strategically about coloring.
- **DFS Logic**: The DFS function in the code might not handle the cycle correctly, especially when it comes to coloring vertices in a way that avoids conflicts.
- **Bob's Strategy**: The code for Bob's strategy might not handle the cycle well, leading to a situation where Alice can force a win.
- **Alice's Strategy**: Alice can choose colors in a way that forces Bob to color vertices such that an edge connects two vertices of the same color.

### Expected Behavior
- **Alice's Win**: Alice should be able to force a win by choosing colors in a way that Bob is forced to color two adjacent vertices with the same color.
- **Bob's Strategy**: Bob's strategy should ideally prevent Alice from winning, but the cycle structure makes it challenging to do so without careful consideration.

This test case is small and complete, making it a good candidate to expose potential bugs in the provided code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
/**
 *    author:  maksonchik20
 *    created: 28.07.2024 19:30:56
**/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>

using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;

#define all(x) x.begin(), x.end()
#define for0(i, n) for (ll   i = 0; i < (n); ++i)
#define for1(i, n) for (ll   i = 1; i < (n); ++i)
#define rfor0(i, n) for (ll   i = (n) - 1; i >= 0; --i)
#define rfor1(i, n) for (ll   i = (n) - 1; i >= 1; --i)
#define rep(i, a, n) for (ll   i = a; i < ll(n); ++i)
#define rrep(i, a, n) for (ll   i = a - 1; i >= ll(n); --i)
#define fastIO() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define sz(x) ll(x.size())

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<char> vc;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef vector<string> vs;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ull> vull;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<pll> vpll;
typedef pair<double, double> pdd;
typedef long double ld;
typedef vector<ld> vld;
typedef vector<pair<ld, ld>> vpld;
typedef string str;
typedef set<ll> sll;
typedef set<int> si;
typedef set<str> ss;
typedef set<pii> spii;
typedef multiset<int> msi;
typedef multiset<ll> msll;
typedef multiset<str> mss;
typedef multiset<pii> mspii;
typedef multiset<pll> mspll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvll;
typedef queue<int> qi;
typedef queue<ll> qll;
typedef queue<pair<ll, ll>> qpll;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
typedef tree<ll, null_type, less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_multiset;

constexpr long double PI = 3.141592653589793238462643383279;
const ll mod1 = 1e9 + 7;
const ll mod2 = 998244353;
const ll INF = 9223372036854775807;
const ll INFINT = 2147483647;
const long double eps = 1e-9;

template<typename T>
istream &operator>>(istream &in, vector<T> &a) {
    for (T &i : a) in >> i;
    return in;
}

template<typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &a) {
    in >> a.fi >> a.se;
    return in;
}

template<typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &a) {
    out << a.fi << " " << a.se;
    return out;
}

template<typename T1, typename T2>
istream &operator>>(istream &in, vector<pair<T1, T2>> &a) {
    for (pair<T1, T2> &i : a) in >> i.fi >> i.se;
    return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &a) {
    for (auto i : a) {
        out << i << " ";
    }
    return out;
}

template<typename T1, typename T2>
ostream &operator<<(ostream &out, vector<pair<T1, T2>> &a) {
    for (pair<T1, T2> i : a) out << i.fi << " " << i.se << endl;
    return out;
}

template<typename T1>
ostream &operator<<(ostream &out, vector<vector<T1>> &a) {
    for (vector<T1> i : a) {
        for (T1 j : i) out << j << " ";
        out << endl;
    }
    return out;
}

template<typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
    b = (T1) b;
    return a > b ? b : a;
}

template<typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
    b = (T1) b;
    return a > b ? a : b;
}

template<typename T1, typename T2>
inline void amin(T1 &a, T2 b) {
    a = min(a, b);
}

template<typename T1, typename T2>
inline void amax(T1 &a, T2 b) {
    a = max(a, b);
}

double getTime() {
    return clock() / (double) CLOCKS_PER_SEC;
}

mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

ll rndlr(ll l, ll r) {
    ll a = rnd() % (r - l + 1) + l;
    return a;
}

int n, m;
vector<bool> used;
vector<int> color;
bool ok = true;
vector<vector<int>> g;
vector<int> ans;

void dfs(int v, int c) {
    used[v] = true;
    color[v] = c;
    // if (c == 1) {
    //     ans.push_back(v + 1);
    // }
    for (auto to : g[v]) {
        if (used[to] && color[to] == color[v]) {
            ok = false;
        }
        if (!used[to]) {
            if (c == 1) {
                dfs(to, 2);
            } else {
                dfs(to, 1);
            }
        }
    }
}

void solve() {
    cin >> n >> m;
    used.assign(n, false);
    color.assign(n, 0);
    g.assign(n, vector<int>());
    ok = true;
    ans.clear();
    set<int> st;
    for (int i = 0; i < n; ++i) {
        st.insert(i);
    }
    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        u--;
        v--;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for (int i = 0; i < n; ++i) {
        if (!used[i]) {
            dfs(i, 1);
        }
    }
    if (ok) {
        cout << "Bob" << endl;
        for (int i = 0; i < n; ++i) {
            int a, b;
            cin >> a;
            if (a == -1) {
                exit(1);
            }
            cin >> b;
            if (a > b) {
                swap(a, b);
            }
            auto it = st.begin();
            int el = *it;
            st.erase(st.begin());
            cout << el + 1 << " ";
            if (color[el] == 2 && (a == 2 || b == 2)) {
                cout << 2 << endl;
            } else if (color[el] == 1 && (a == 1 || b == 1)) {
                cout << 1 << endl;
            } else {
                cout << 3 << endl;
            }
        }
    } else {
        cout << "Alice" << endl;
        for (int i = 0; i < n; ++i) {
            cout << "1 2" << endl;
            int u, v;
            cin >> u;
            if (u == -1) {
                exit(1);
            }
            cin >> v;
        }
    }

}

int main() {
    setlocale(LC_ALL, "Russian");
    // fastIO()
    cout.precision(12);
    cout << fixed;
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

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

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

Think step by step.

Response:
To generate a challenging test input that exposes the bug in the provided buggy code, we need to consider the following aspects:

1. **Graph Structure**: The graph should be such that it can force the algorithm to make decisions that lead to a win for Alice or Bob, depending on the strategy.
2. **Edge Cases**: The test input should include edge cases that are often overlooked, such as a graph with a single edge, a complete graph, or a linear graph.
3. **Input Constraints**: Ensure the input adheres to the given constraints: \(1 \le t \le 1000\), \(1 \le n \le 10^4\), and \(n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)\).

Let's create a test input that can expose the bug:

1. **Single Edge Case**: A graph with two vertices and one edge.
2. **Complete Graph**: A small complete graph (e.g., \(K_3\)).
3. **Linear Graph**: A linear graph (e.g., a path with 4 vertices).

Here is the test input:

```plaintext
3
2 1
1 2

3 3
1 2
2 3
3 1

4 3
1 2
2 3
3 4
```

### Explanation:

1. **Single Edge Case**:
   - **Graph**: 2 vertices, 1 edge.
   - **Expected Output**: Alice wins. Alice can choose any two colors, and Bob has no choice but to color both vertices with different colors, leading to a win for Alice.

2. **Complete Graph**:
   - **Graph**: 3 vertices, 3 edges (forming a triangle).
   - **Expected Output**: Alice wins. Alice can choose any two colors, and Bob will eventually be forced to color two adjacent vertices with the same color, leading to a win for Alice.

3. **Linear Graph**:
   - **Graph**: 4 vertices, 3 edges (forming a path).
   - **Expected Output**: Bob wins. Bob can always choose colors such that no two adjacent vertices have the same color, leading to a win for Bob.

This test input covers different scenarios and should help expose any bugs in the provided buggy code.


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
import sys
T=int(input())
for _ in range(T):
	n,m=[int(z) for z in input().split()]

	adj = [[] for _ in range(n)]
	for e in range(m):
		u,v = [int(z) for z in input().split()]
		u-=1
		v-=1
		adj[u].append(v)
		adj[v].append(u)

	bfs = [0]
	bip = [-1]*n
	bip[0] = 0
	i=0
	happy=True
	sides=[[0],[]]
	while i<len(bfs):
		u = bfs[i]
		d = bip[u]
		for v in adj[u]:
			if bip[v]==d:
				happy=False
				break
			elif bip[v]==-1:
				bip[v]=1-d
				sides[1-d].append(v)
				bfs.append(v)
		if not happy:break
		i+=1

	if happy:
		print("Bob")
		sys.stdout.flush()
		dead = -1
		for i in range(n):
			a,b=[int(z) for z in input().split()]
			a-=1
			b-=1
			if dead==-1:
				c=a if a!=2 else b
				print(sides[c].pop()+1,c+1)
				if len(sides[c])==0:dead=c
			else:
				c=a if a!=dead else b
				print(sides[1-dead].pop()+1,c+1)
			sys.stdout.flush()
	else:
		print("Alice")
		for i in range(n):
			print(1,2)
			sys.stdout.flush()
			if input()=="-1":
				quit()

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

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

Think step by step.

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

import sys

def is_bipartite(graph):
    n = len(graph)
    color = [-1] * n

    for start in range(n):
        if color[start] == -1:
            color[start] = 0
            stack = [start]

            while stack:
                parent = stack.pop()

                for child in graph[parent]:
                    if color[child] == -1:
                        color[child] = 1 - color[parent]
                        stack.append(child)
                    elif color[parent] == color[child]:
                        return False, color

    return True, color

def play_as_alice(n):
    for _ in range(n):
        print("1 2")
        sys.stdout.flush()
        input()  # Read Bob's move, but we don't need to use it

def play_as_bob(n, graph, bipartite_coloring):
    colors = [0] * n  # 0: uncolored, 1, 2, 3: actual colors
    color_map = {}  # To maintain consistent mapping of bipartite colors to actual colors

    for _ in range(n):
        a, b = map(int, input().split())

        # Ensure consistent mapping of colors
        if not color_map:
            color_map[0] = min(a, b)
            color_map[1] = max(a, b)

        # Find an uncolored vertex
        v = next(i for i in range(n) if colors[i] == 0)

        # Choose the color that matches the bipartite coloring
        desired_color = color_map[bipartite_coloring[v]]
        c = a if desired_color == a else b

        colors[v] = c
        print(f"{v+1} {c}")
        sys.stdout.flush()

def solve_case():
    n, m = map(int, input().split())
    graph = [[] for _ in range(n)]
    for _ in range(m):
        u, v = map(int, input().split())
        u -= 1  # Convert to 0-indexed
        v -= 1  # Convert to 0-indexed
        graph[u].append(v)
        graph[v].append(u)

    is_bip, coloring = is_bipartite(graph)

    if is_bip:
        print("Bob")
        sys.stdout.flush()
        play_as_bob(n, graph, coloring)
    else:
        print("Alice")
        sys.stdout.flush()
        play_as_alice(n)

def main():
    t = int(input())
    for _ in range(t):
        solve_case()

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._file = 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")

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()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

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 given code, we need to focus on scenarios where the bipartite check might fail or where the color assignment strategy might not work as expected. The code assumes that if the graph is bipartite, Bob can always win by consistently coloring vertices based on the bipartite coloring. However, this strategy can fail if the graph is not properly bipartite or if there are specific edge cases that the code does not handle correctly.

### Step-by-Step Analysis:

1. **Bipartite Check:**
   - The code uses a depth-first search (DFS) to check if the graph is bipartite. If the graph is not bipartite, Alice wins by default.
   - We need to ensure that the graph is bipartite to focus on Bob's strategy.

2. **Bob's Strategy:**
   - Bob's strategy is to consistently color vertices based on the bipartite coloring.
   - If the graph is bipartite, Bob should be able to win by ensuring that no two adjacent vertices have the same color.
   - However, if the graph has a specific structure that forces Bob to make a wrong move, Alice can win.

3. **Edge Cases:**
   - Consider a graph with a small number of vertices and edges that is bipartite but has a specific structure that can force Bob to make a wrong move.
   - For example, a graph with 4 vertices and 4 edges forming a cycle (a bipartite graph) but with a specific edge order that can confuse the code.

### Test Input:

Let's create a test case with a small bipartite graph that can expose the bug in Bob's strategy.

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

### Explanation:

- **Graph Description:**
  - The graph has 4 vertices and 4 edges, forming a cycle.
  - The edges are given in the order: (1, 2), (2, 3), (3, 4), (4, 1).

- **Bipartite Check:**
  - This graph is bipartite. We can color vertices 1 and 3 with one color and vertices 2 and 4 with another color.

- **Bob's Strategy:**
  - Bob should be able to win by consistently coloring vertices based on the bipartite coloring.
  - However, if Alice chooses colors in a way that forces Bob to make a wrong move, Alice can win.

- **Expected Behavior:**
  - If the code is correct, Bob should win by consistently coloring vertices based on the bipartite coloring.
  - If the code has a bug, Alice can win by forcing Bob to make a wrong move.

### Output:

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


**Task:**
Generate a challenging test input that exposes the bug in the buggy code of the algorithm problem:
Algorithm Problem:
Title: Coloring Game
time_limit_ms: 2000
memory_limit_mb: 256
Description: This is an interactive problem.

Consider an undirected connected graph consisting of $$$n$$$ vertices and $$$m$$$ edges. Each vertex can be colored with one of three colors: $$$1$$$, $$$2$$$, or $$$3$$$. Initially, all vertices are uncolored.

Alice and Bob are playing a game consisting of $$$n$$$ rounds. In each round, the following two-step process happens:

1. Alice chooses two different colors.
2. Bob chooses an uncolored vertex and colors it with one of the two colors chosen by Alice.

Alice wins if there exists an edge connecting two vertices of the same color. Otherwise, Bob wins.

You are given the graph. Your task is to decide which player you wish to play as and win the game.

Input: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \le n \le 10^4$$$, $$$n - 1 \le m \le \min(\frac{n \cdot (n - 1)}{2}, 10^4)$$$) — the number of vertices and the number of edges in the graph, respectively.

Each of the next $$$m$$$ lines of each test case contains two integers $$$u_i$$$, $$$v_i$$$ ($$$1 \le u_i, v_i \le n$$$) — the edges of the graph. It is guaranteed that the graph is connected and there are no multiple edges or self-loops.

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

Output: None

Examples:
input:
2
3 3
1 2
2 3
3 1

3 1

2 2

1 1
4 4
1 2
2 3
3 4
4 1

2 3

1 2

2 1

3 1
output:
Alice
3 1

1 2

2 1

Bob

1 2

2 1

4 1

3 3

Note: Note that the sample test cases are example games and do not necessarily represent the optimal strategy for both players.

In the first test case, you choose to play as Alice.

1. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$1$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$2$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$1$$$.

Alice wins because the edge $$$(3, 1)$$$ connects two vertices of the same color.

In the second test case, you choose to play as Bob.

1. Alice chooses two colors: $$$2$$$ and $$$3$$$. Bob chooses vertex $$$1$$$ and colors it with color $$$2$$$.
2. Alice chooses two colors: $$$1$$$ and $$$2$$$. Bob chooses vertex $$$2$$$ and colors it with color $$$1$$$.
3. Alice chooses two colors: $$$2$$$ and $$$1$$$. Bob chooses vertex $$$4$$$ and colors it with color $$$1$$$.
4. Alice chooses two colors: $$$3$$$ and $$$1$$$. Bob chooses vertex $$$3$$$ and colors it with color $$$3$$$.

Bob wins because there are no edges with vertices of the same color.

Buggy Code:
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main {
	static kattio sc = new kattio();
	static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static boolean p1,p2;
	public static void main(String[] args) {

		p1=false;
		int t = sc.nextint();
		while (t-- > 0) {
			if (t==10000-59) {
				//p1=true;
			}
			sovle1();
			p1=false;
		}

		out.close();

	}
	static int n,m,k;
	static long [][]dp,min;
	static long sum;
	static long[]ans,ans2,he;
	static int[] v,arr,fa;
	static Map<Long, Long>valuMap;
	static void sovle2() {
		n=sc.nextint();
		int []arr=new int[n];
		int []ans=new int[n];

		for (int i = 1; i < arr.length; i++) {
			arr[i]=sc.nextint();

		}
		ans[0]=arr[1];
		for (int i = 1; i < arr.length-1; i++) {
			if ((arr[i-1]&arr[i+1])!=0) {
				out.println(-1);return;
			}
		}
		for (int i = 1; i < ans.length-1; i++) {
			ans[i]=arr[i]|arr[i+1];

		}
		ans[n-1]=arr[n-1];
		for (int i = 0; i < ans.length; i++) {
			out.print(ans[i]+" ");
		}
		out.println();
	}

	static long id(int u,int v) {
		if (u<v) {
			return 1l*u*n+v;
		}else {
			return 1l*v*n+u;
		}
	}
	static void sovle1 () {
		n=sc.nextint();
		m=sc.nextint();
		map=new HashMap<Integer, List<Integer>>();
		for (int i = 0; i < n; i++) {
			map.put(i+1, new ArrayList<Integer>());
		}
		for (int i = 0; i < m; i++) {
			int u=sc.nextint();
			int v=sc.nextint();
			map.get(u).add(v);
			map.get(v).add(u);
		}
		hie=new int[n+1];
		bj=new int[n+1];
		d=0;
		dfs1(1, 0);
		if (d==0) {
			System.out.println("Bob");
			System.out.flush();
			for (int i = 1; i <= n; i++) {
				int u=sc.nextint();
				int v=sc.nextint();
				if (u>v) {
					int c=u;u=v;v=c;
				}
				if (hie[i]%2==1) {
					System.out.println(i+" "+u);
					System.out.flush();
				}else {
					System.out.println(i+" "+v);
					System.out.flush();
				}
			}
		}else {
			System.out.println("Alice");
			System.out.flush();
			for (int i = 1; i <= n; i++) {
				System.out.println(1+" "+2);
				System.out.flush();
				int c=sc.nextint();
				int c1=sc.nextint();
			}
		}
	}
	static int []hie,bj;
	static int d;
	static void dfs1(int x,int fu) {
		hie[x]=hie[fu]+1;bj[x]=1;
		for (int l : map.get(x)) {
			if (l!=fu) {
				if (bj[l]==0) {
					dfs1(l, x);
				}else {
					if ((hie[x]-hie[l]+1)%2==1) {
						d=1;
					}
				}

			}
		}
	}
	static int a,b;
	static void ask(int x,int fu) {
		System.out.println("? "+x);
		System.out.flush();
		a=sc.nextint();
		System.out.println("? "+fu);
		System.out.flush();
		b=sc.nextint();
	}
	static void dfs(int x,int fa) {
		size[x]=1;fu[x]=fa;
		int max=0;int mi=0;
		for (int l : map.get(x)) {
			if (l!=fa) {
				dfs(l, x);
				size[x]+=size[l];
				if (size[l]>max) {
					max=size[l];
					mi=l;
				}
			}
		}
		bigson[x]=mi;
	}
	static int []size,fu,bigson;

	static void sovle() {
		n=sc.nextint();
		arr=new int[n+1];
		for (int i = 1; i < arr.length; i++) {
			arr[i]=sc.nextint();
		}
		ls = new int[n + 1];Arrays.fill(ls, 0);
		rs = new int[n + 1];Arrays.fill(rs, n+1);
		Stack<Integer>stack=new Stack<Integer>();
		for (int i = 1; i < arr.length; i++) {
			while (!stack.isEmpty()&&arr[stack.peek()]>arr[i]) {
				stack.pop();
			}
			if (!stack.isEmpty()) {
				ls[i]=stack.peek();
			}
			stack.add(i);
		}
		stack.clear();
		for (int i = n; i >0; i--) {
			while (!stack.isEmpty()&&arr[stack.peek()]>arr[i]) {
				stack.pop();
			}
			if (!stack.isEmpty()) {
				rs[i]=stack.peek();
			}
			stack.add(i);
		}
		System.out.println(Arrays.toString(ls));
		System.out.println(Arrays.toString(rs));
		long sum=0;
		int [][]va=new int[n+1][2];
		int[]fu=new int[n+1];
		int gen=0;
		for (int i = 1; i < arr.length; i++) {
			va[i][0]=i-ls[i];
			va[i][1]=rs[i]-i;
			if (ls[i]!=0&&rs[i]!=n+1) {
				if (arr[ls[i]]<arr[rs[i]]) {
					fu[i]=rs[i];
				}else {
					fu[i]=ls[i];
				}
			}else if (ls[i]!=0) {
				fu[i]=ls[i];
			}else if (rs[i]!=n+1) {
				fu[i]=rs[i];
			}
			sum+=1l*va[i][0]*va[i][1]*arr[i];
			if (arr[i]==1) {
				gen=i;
			}
		}
		map=new HashMap<Integer, List<Integer>>();
		for (int i = 0; i < fu.length; i++) {
			map.put(i, new ArrayList<Integer>());
		}
		System.out.println(Arrays.toString(fu));
		//System.out.println(Arrays.toString(ls));
		//System.out.println(Arrays.toString(rs));
		for (int i = 1; i < fu.length; i++) {

			map.get(fu[i]).add(i);
		}
		ans=new long[n+1];
		ans2=new long[n+1];
		dfs(gen, 0, va);
		System.out.println(Arrays.toString(ans)+" "+sum);
		System.out.println(Arrays.toString(ans2));
		for (int i = 1; i < ans.length; i++) {
			out.print((sum-ans[i]+ans2[i])+" ");
		}
		out.println();

		System.out.println(map);
	}
	static int []ls,rs;
	static void dfs(int x,int fu,int[][]va) {
		//System.out.println(x+" "+Arrays.toString(va[x]));
		if (fu!=0) {
			if (x<fu) {
				ans[x]+=1l*arr[fu]*va[fu][1];
			}else {
				ans[x]+=1l*arr[fu]*va[fu][1];
			}
		}
		ans[x]+=ans[fu];
		int shang=-1;
		for (int a : map.get(x)) {
			dfs(a, x, va);
			ans2[x]+=ans2[a];
			if (shang!=-1) {
				if (shang<a) {
					if (arr[shang]>arr[a]) {
						ans2[x]+=1l*arr[a]*va[a][1]*(va[shang][0]+va[shang][1]-1);
						//System.out.println(arr[a]);
					}else {
						ans2[x]+=1l*arr[shang]*va[shang][0]*(va[a][0]+va[a][1]-1);
					}
				}else {
					if (arr[shang]>arr[a]) {
						ans2[x]+=1l*arr[a]*va[a][0]*(va[shang][0]+va[shang][1]-1);
					}else {
						ans2[x]+=1l*arr[shang]*va[shang][1]*(va[a][0]+va[a][1]-1);
					}
				}
			}
			shang=a;
		}
		ans[x]+=1l*va[x][0]*va[x][1]*arr[x];
	}

	static Map<Integer, Integer> lMap, rMap;
	static Map<Integer, TreeSet<Integer>> vMap;

	static int[] dx = { 0, 0, 1, -1 };
	static int[] dy = { 1, -1, 0, 0 };
	static Map<Integer, List<Integer>> lpMap;

	static long pow(long x, long a) {
		if (a == 0) {
			return 1;
		} else {
			long c = pow(x, a / 2);
			if (a % 2 == 0) {
				return c * c % mod;
			} else {
				return c * c % mod * x % mod;
			}
		}
	}

	static long mod = (long) (1e9+7);

	static long gcd(long a, long b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	static long[] c,value;

	static int lowbit(int x) {
		return x & -x;
	}

	static void add(int x, int v) {
		while (x < c.length) {
			c[x] += v;
			if (c[x]==1) {
				value[x]+=1;
			}
			if (c[x]==0) {
				value[x]-=1;
			}
			x += lowbit(x);
		}
	}

	static long sum(int x) {
		long ans = 0;
		while (x > 0) {
			// System.out.println(x);
			ans += value[x];
			x -= lowbit(x);
		}
		return ans;
	}

	static Map<Integer, List<Integer>> map;

	static void mapinit(int chu, int n) {
		map = new HashMap<Integer, List<Integer>>();
		for (int i = chu; i < n + chu; i++) {
			map.put(i, new ArrayList<Integer>());
		}
	}
}

class kattio extends PrintWriter {

	BufferedReader r;
	StringTokenizer st;

	public kattio() {
		this(System.in, System.out);
	}

	public kattio(InputStream i, OutputStream o) {
		super(o);
		r = new BufferedReader(new InputStreamReader(i));
	}

	public kattio(String in, String out) throws IOException {
		super(out);
		r = new BufferedReader(new FileReader(in));
	}

	public String next() {
		try {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(r.readLine());
			}
			return st.nextToken();
		} catch (Exception e) {
			// TODO: handle exception
			return null;
		}
	}

	public int nextint() {
		return Integer.parseInt(next());
	}

	public long nextlong() {
		return Long.parseLong(next());
	}

	public double nextdouble() {
		return Double.parseDouble(next());
	}
}

**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 for the provided buggy code, we need to focus on edge cases and scenarios that can expose the bug. The key is to create a graph where the current logic of the code might fail. Here are the steps to think through the process:

1. **Understand the Bug**: The buggy code seems to have an issue in the depth-first search (DFS) logic used to determine the winner. Specifically, it incorrectly determines the depth and uses it to decide the winner.

2. **Create a Test Case**:
   - **Small Scale**: The test case should be small enough to be manageable but complex enough to expose the bug.
   - **Connected Graph**: Ensure the graph is connected, as required by the problem.
   - **Edge Case**: Consider a graph where the DFS logic might incorrectly determine the depth, leading to a wrong winner.

3. **Example Graph**:
   - A simple example is a linear graph (path graph) where each vertex is connected to the next one. This can be a good candidate because the DFS logic might incorrectly handle the depth of such a graph.

4. **Test Case**:
   - **Number of Test Cases**: 1
   - **Vertices and Edges**: 5 vertices and 4 edges
   - **Edges**: (1, 2), (2, 3), (3, 4), (4, 5)

Here is the test input:

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

This test case is small and complete. It represents a linear graph where each vertex is connected to the next one. This graph is connected, and it should be easy to verify the correctness of the solution. The DFS logic in the buggy code might fail to correctly determine the depth of the vertices, leading to a wrong decision on the winner.