#include <bits/stdc++.h>
using namespace std;
int q;
map<string, set<string>> m;
int main() {
    cin >> q;
    while(q --) {
        int op;
        string x, y;
        cin >> op;
        if(op == 1) {
            cin >> x >> y;
            m[x].insert(y);
        } else if(op == 2) {
            cin >> x;
            if(!m.count(x)) cout << 0 << endl;
            else cout << m[x].size() << endl;
        } else if(op == 3) {
            cin >> x >> y;
            if(!m.count(x)) cout << 0 << endl;
            else if(!m[x].count(y)) cout << 0 << endl;
            else cout << 1 << endl;
        } else if(op == 4) {
            cout << m.size() << endl;
        }
    }
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int q = scanner.nextInt();
        Map<String, Set<String>> m = new HashMap<>();

        while (q-- > 0) {
            int op = scanner.nextInt();
            if (op == 1) {
                String x = scanner.next();
                String y = scanner.next();
                m.computeIfAbsent(x, k -> new HashSet<>()).add(y);
            } else if (op == 2) {
                String x = scanner.next();
                System.out.println(m.getOrDefault(x, Collections.emptySet()).size());
            } else if (op == 3) {
                String x = scanner.next();
                String y = scanner.next();
                if (!m.containsKey(x)) {
                    System.out.println(0);
                } else {
                    System.out.println(m.get(x).contains(y) ? 1 : 0);
                }
            } else if (op == 4) {
                System.out.println(m.size());
            }
        }
    }
}

from collections import defaultdict
m = defaultdict(set)
q = int(input())
for _ in range(q):
    line = input().split()
    op = int(line[0])
    if op == 1:
        x, y = line[1], line[2]
        m[x].add(y)
    elif op == 2:
        x = line[1]
        print(len(m[x]) if x in m else 0)
    elif op == 3:
        x, y = line[1], line[2]
        print(1 if x in m and y in m[x] else 0)
    elif op == 4:
        print(len(m))

#include <bits/stdc++.h>
using namespace std;
#define ll long long
string S;
ll N, P, ans = 1;
int main() {
	cin >> S >> P;
	while(S.at(0) == '0') S.erase(S.begin());
	if(S.length() > 7) {
		cout << 0;
		return 0;
	}
	istringstream ss(S);
	ss >> N;
	for(int i = 1; i <= P && i <= N; i ++) (ans *= i) %= P;
	cout << ans;
	return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String S = scanner.next();
        long P = scanner.nextLong();
        long ans = 1;
        if (S.length() > 7) {
            System.out.println(0);
            return;
        }
        long N = Long.parseLong(S);
        for (int i = 1; i <= P && i <= N; i++) {
            ans = (ans * i) % P;
        }
        System.out.println(ans);
    }
}

from functools import reduce
line = input().split()
n, p = int(line[0]), int(line[1])
if n < p:
    print(reduce(lambda x,y:x*y%p,range(1,n+1)))
else:
    print(0)

#include <iostream>
#include <cstring>
#include <bitset>

using namespace std;

const int N = 20, M = 1e3, K = 1e4;

int n,m,k,a[N + 2];

bitset<K> y,all;

int main() {
	cin>>n>>m>>k;
	for(int i=1; i<=n; ++i) cin>>a[i];
	for(int i=0; i<k; ++i) all[i]=1;
	for(int i=1; i<=m; ++i) {
		string s;
		cin>>s;
		y.reset();
		for(int j=0; j<s.size(); ++j) y[s.size()-j-1]=s[j]-'0';
		for(int p=n; p>=1; --p)
			if(a[p]>0) for(int j=a[p]; j<k; j*=2) y=(y^(y<<j))&all;
			else for(int j=-a[p]; j<k; j*=2) y=(y^(y>>j))&all;
		bool f=false;
		for(int i=k-1; i>=0; --i)
			if(f|=y[i])
				cout<<int(y[i]);
		if(!f) cout<<'0';
		cout<<endl;
	}
	return 0;
}

#include <bits/stdc++.h>
#define N 10010
using namespace std;
int n, m, k;
int a[40];
int main() {
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= m; i++) {
        string str;
        cin >> str;
        bitset<N> s;
        for (int i = 0; i < str.size(); i++) {
            s[i] = str[str.size() - 1 - i] - '0';
        }
        for (int i = n; i > 0; i--) {
            bitset<N> t = s;
            if (a[i] > 0) {
                for (int j = a[i]; j < k; j++) {
                    t[j] = t[j] ^ t[j - a[i]];
                }
            } else {
                for (int j = k - 1 + a[i]; j >= 0; j--) {
                    t[j] = t[j] ^ t[j - a[i]];
                }
            }
            s = t;
        }
        int flag = 0;
        for (int i = k - 1; i >= 0; i--) {
            if (s[i]) flag = 1;
            if (flag) cout << s[i];
        }
        if (!flag) cout << 0;
        cout << endl;
    }
}

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 1000010
int t, n, m, ans;

struct PI {
	int first, second;
	PI(int a, int b) {first = a, second = b;}
};

namespace Graph {
	int head[N];
	int nxt[2*N];
	int to[2*N], cnt;
	
	void addEdge(int u, int v) {
		cnt++;
		to[cnt] = v;
		nxt[cnt] = head[u];
		head[u] = cnt;
	}
	
	void init() {
		__builtin_memset(head, 0, sizeof head);
		cnt = 0;
	}
}

namespace Loop {
	int dfn[N], fa[N], ti;
	int loop[N], num, flag[N];
	void dfs(int u) {
		using namespace Graph;
		dfn[u] = ++ti;
		for(int i = head[u]; i; i = nxt[i]) {
			int v = to[i];
			if(v == fa[u]) continue;
			if(!dfn[v]) {
				fa[v] = u;
				dfs(v);
			} else if(dfn[v] > dfn[u]) {
				for(; v != fa[u]; v = fa[v]) {
					loop[++num] = v;
					flag[v] = 1;
				}
			}
		}
	}
	
	void solve() {
		__builtin_memset(dfn, 0, sizeof dfn);
		__builtin_memset(fa, 0, sizeof fa);
		__builtin_memset(loop, 0, sizeof loop);
		__builtin_memset(flag, 0, sizeof flag);
		ti = num = 0;
		dfs(1);
	}
}

namespace Punch {
	int res;
	bool f[N];
	bool inTree;
	int nou, nov;
	
	void dfs(int u, int fa) {
		using namespace Graph;
		f[u] = 1;
		int sum = 0;
		for(int i = head[u]; i; i = nxt[i]) {
			int v = to[i];
			if(v == fa) continue;
			if(inTree && Loop::flag[v]) continue;
			if(u == nou && v == nov) continue;
			if(u == nov && v == nou) continue;
			
			dfs(v, u);
			sum += f[v];
		}
		
		if(sum) f[u] = 0, sum--;
		res += sum;
	}
	
	PI solve(int u, int _nou, int _nov, bool _inTree) {
		res = 0;
		inTree = _inTree, nou = _nou, nov = _nov;
		
		dfs(u, 0);
		return PI(res, f[u]);
	}
}

int main() {
	scanf("%d", &t);
	while(t--) {
		ans = 0;
		Graph::init();
		scanf("%d %d", &n, &m);
		for(int i = 1; i <= m; i++) {
			int u, v;
			scanf("%d %d", &u, &v);
			Graph::addEdge(u, v);
			Graph::addEdge(v, u);
		}
		
		Loop::solve();
		
		if(Loop::num == 0) {
			auto res = Punch::solve(1, 0, 0, 0);
			ans = res.first + res.second;
		} else {
			auto res = Punch::solve(1, Loop::loop[2], Loop::loop[3], 0);
			ans = res.first + res.second;
			
			res = Punch::solve(1, Loop::loop[1], Loop::loop[2], 0);
			ans = min(ans, res.first + res.second);
			
			int sum = 0;
			for(int i = 1; i <= Loop::num; i++) {
				res = Punch::solve(Loop::loop[i], 0, 0, 1);
				sum += res.first + (res.second ^ 1);
			}
			ans = min(ans, sum);
		}
		
		if(ans == 0) printf("Yes\n");
		else printf("%d\n", ans);
	}
	
	return 0;
}

// writer: 牛客lulu
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int __FAST_IO__ = []() {
    std::ios::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
    return 0;
}();

void solve() {
    int n, m;
    cin >> n >> m;
    if (n == 1) {
        cout << "1\n";
        return;
    }
    vector<vector<int>> g(n);
    vector<int> deg(n, 0), vis(n, 0);
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        g[u - 1].push_back(v - 1);
        g[v - 1].push_back(u - 1);
        deg[u - 1]++;
        deg[v - 1]++;
    }

    int ans = 0;
    queue<int> qs;
    for (int i = 0; i < n; i++) {
        if (deg[i] == 1) {
            qs.push(i);
        }
    }
    while (!qs.empty()) {
        auto u = qs.front();
        qs.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        int v = -1;
        for (auto x : g[u]) {
            if (!vis[x]) {
                v = x;
                break;
            }
        }
        if (v == -1) {
            ans++;
            continue;
        }
        vis[v] = 1;
        for (auto x : g[v]) {
            if (!vis[x]) {
                deg[x]--;
                if (deg[x] == 1) {
                    qs.push(x);
                }
            }
        }
    }
    if (ans) cout << ans << "\n";
    else cout << "Yes\n";
}

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

from math import gcd, lcm
P = 998244353

def run(x, n, a, b):
    x = ((x - 1) % n + n) % n + 1
    sz = 0
    tmp = x
    if 1 <= tmp <= a + b - n:
        sz += 1
        tmp += n * 2 - a - b
    elif a + b - n + 1 <= tmp <= a:
        sz += 1
        tmp = a + 1 - tmp
    elif a + 1 <= tmp <= n:
        sz += 1
        tmp = n * 2 - b + 1 - tmp
    while tmp != x:
        if 1 <= tmp <= a + b - n:
            if 1 <= x <= a + b - n and x >= tmp and (x - tmp) % (n * 2 - a - b) == 0:
                step = (x - tmp) // (n * 2 - a - b)
            else:
                step = (a + b - n - tmp + (n * 2 - a - b)) // (n * 2 - a - b)
            sz += step
            tmp += step * (n * 2 - a - b)
        elif a + b - n + 1 <= tmp <= a:
            sz += 1
            tmp = a + 1 - tmp
        elif a + 1 <= tmp <= n:
            sz += 1
            tmp = n * 2 - b + 1 - tmp
    return sz

T = int(input())
for _ in range(T):
    ans = 1
    n, a, b = map(int, input().split())
    if a == 1 and b == 1:
        print(1)
        continue
    if a == 1:
        print(2)
        continue
    if b == 1:
        print(2)
        continue
    if a + b <= n:
        print(4)
        continue
    ans = lcm(ans, run(a, n, a, b))
    ans = lcm(ans, run(a + b - n + 1, n, a, b))
    ans = lcm(ans, run(n, n, a, b))
    ans = lcm(ans, run(a + 1, n, a, b))
    ans = lcm(ans, run(1, n, a, b))
    ans = lcm(ans, run(a + b - n, n, a, b))
    print((ans * 2) % P)

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define P 998244353


const int maxn = 1000;  
  
struct bign{  
    int d[maxn], len;  
  
    void clean() { while(len > 1 && !d[len-1]) len--; }  
  
    bign()          { memset(d, 0, sizeof(d)); len = 1; }  
    bign(int num)   { *this = num; }   
    bign(char* num) { *this = num; }  
    bign operator = (const char* num){  
        memset(d, 0, sizeof(d)); len = strlen(num);  
        for(int i = 0; i < len; i++) d[i] = num[len-1-i] - '0';  
        clean();  
        return *this;  
    }  
    bign operator = (int num){  
        char s[20]; sprintf(s, "%d", num);  
        *this = s;  
        return *this;  
    }  
  
    bign operator + (const bign& b){  
        bign c = *this; int i;  
        for (i = 0; i < b.len; i++){  
            c.d[i] += b.d[i];  
            if (c.d[i] > 9) c.d[i]%=10, c.d[i+1]++;  
        }  
        while (c.d[i] > 9) c.d[i++]%=10, c.d[i]++;  
        c.len = max(len, b.len);  
        if (c.d[i] && c.len <= i) c.len = i+1;  
        return c;  
    }  
    bign operator - (const bign& b){  
        bign c = *this; int i;  
        for (i = 0; i < b.len; i++){  
            c.d[i] -= b.d[i];  
            if (c.d[i] < 0) c.d[i]+=10, c.d[i+1]--;  
        }  
        while (c.d[i] < 0) c.d[i++]+=10, c.d[i]--;  
        c.clean();  
        return c;  
    }  
    bign operator * (const bign& b)const{  
        int i, j; bign c; c.len = len + b.len;   
        for(j = 0; j < b.len; j++) for(i = 0; i < len; i++)   
            c.d[i+j] += d[i] * b.d[j];  
        for(i = 0; i < c.len-1; i++)  
            c.d[i+1] += c.d[i]/10, c.d[i] %= 10;  
        c.clean();  
        return c;  
    }  
    bign operator / (const bign& b){  
        int i, j;  
        bign c = *this, a = 0;  
        for (i = len - 1; i >= 0; i--)  
        {  
            a = a*10 + d[i];  
            for (j = 0; j < 10; j++) if (a < b*(j+1)) break;  
            c.d[i] = j;  
            a = a - b*j;  
        }  
        c.clean();  
        return c;  
    }  
    bign operator % (const bign& b){  
        int i, j;  
        bign a = 0;  
        for (i = len - 1; i >= 0; i--)  
        {  
            a = a*10 + d[i];  
            for (j = 0; j < 10; j++) if (a < b*(j+1)) break;  
            a = a - b*j;  
        }  
        return a;  
    }  
    bign operator += (const bign& b){  
        *this = *this + b;  
        return *this;  
    }  
  
    bool operator <(const bign& b) const{  
        if(len != b.len) return len < b.len;  
        for(int i = len-1; i >= 0; i--)  
            if(d[i] != b.d[i]) return d[i] < b.d[i];  
        return false;  
    }  
    bool operator >(const bign& b) const{return b < *this;}  
    bool operator<=(const bign& b) const{return !(b < *this);}  
    bool operator>=(const bign& b) const{return !(*this < b);}  
    bool operator!=(const bign& b) const{return b < *this || *this < b;}  
    bool operator==(const bign& b) const{return !(b < *this) && !(b > *this);}  
  
    string str() const{  
        char s[maxn]={};  
        for(int i = 0; i < len; i++) s[len-1-i] = d[i]+'0';  
        return s;  
    }  
};  
  
istream& operator >> (istream& in, bign& x)  
{  
    string s;  
    in >> s;  
    x = s.c_str();  
    return in;  
}  
  
ostream& operator << (ostream& out, const bign& x)  
{  
    out << x.str();  
    return out;  
}

ll T;
bign ans = 1, n, a, b;
bign gcd(bign a, bign b) {
	if(b == 0) return a;
	return gcd(b, a % b);
}
bign lcm(bign a, bign b) {
	return a * b / gcd(a, b);
}
void run(bign x) {
	x = ((x - bign(1)) % n + n) % n + bign(1);
	bign sz = 0, tmp = x;
	if(bign(1) <= tmp && tmp <= a + b - n) {
		sz += 1;
		tmp += n * bign(2) - a - b;
	} else if(a + b - n + bign(1) <= tmp && tmp <= a) {
		sz += 1;
		tmp = a + bign(1) - tmp;
	} else if(a + bign(1) <= tmp && tmp <= n) {
		sz += 1;
		tmp = n * 2 - b + bign(1) - tmp;
	}
	while(tmp != x) {
		if(bign(1) <= tmp && tmp <= a + b - n) {
			bign step = 0;
			if(bign(1) <= x && x <= a + b - n && x >= tmp && (x - tmp) % (n * 2 - a - b) == 0) {
				step = (x - tmp) / (n * bign(2) - a - b);
			} else {
				step = (a + b - n - tmp + (n * 2 - a - b)) / (n * bign(2) - a - b);
			}
			sz += step;
			tmp += step * (n * bign(2) - a - b);
		} else if(a + b - n + bign(1) <= tmp && tmp <= a) {
			sz += 1;
			tmp = a + bign(1) - tmp;
		} else if(a + bign(1) <= tmp && tmp <= n) {
			sz += 1;
			tmp = n * 2 - b + bign(1) - tmp;
		}
	}
	ans = lcm(ans, sz);
	// cerr << sz << endl;
}
int main() {
	cin >> T;
	while(T --) {
		ans = 1;
		cin >> n >> a >> b;
		if(a == 1 && b == 1) {
			cout << 1 << endl;
			continue;
		}
		if(a == 1) {
			cout << 2 << endl;
			continue;
		}
		if(b == 1) {
			cout << 2 << endl;
			continue;
		}
		if(a + b <= n) {
			cout << 4 << endl;
			continue;
		}
		run(a);
		run(a + b - n + 1);
		run(n);
		run(a + 1);
		run(1);
		run(a + b - n);
		cout << ans * 2 % P << endl;
	}
	return 0;
}