The game state is defined by an ordered pair $(x, y)$ representing the current values held by the first and second player, together with a global set of previously visited integers. During each turn, the active player must transform their value using one of two operations: multiplication by 2, or integer division by 3 (only when divisible by 3). A transformation is legal only if the resulting value has not appeared in any prior state. The player unable to perform a legal move loses.

This structure permits a recursive solution based on the minimax principle. A game state is classified as winning for the current player if there exists at least one legal move leading to a state that is losing for the opponent. Conversely, a state is losing if every legal move transitions to a winning state for the opponent.

The implementation uses depth-first search with backtracking to explore the game tree. A boolean array tracks occupied values to enforce the uniqueness constraint. Since the value domain is bounded by $[1, 1000]$, the maximum recursion depth $d$ is limited to $\log_2(1000) \approx 10$, yielding a time complexity of $O(2^d)$ per test case.

Two architectural approaches are viable:

Separate Role Functions: Implement distinct functions for the first and second player that mutually recurse. Each function evaluates weather the player to move can force a victory from the current $(x, y)$ configuration.

Unified Evaluation Function: Parameterize the recursive function by turn index (0 or 1) to determine which value to modify. This consolidates the logic into a single routine that alternates players via the parity of the turn counter.

Both approaches maintain the invariant that the visited array is updated upon entry and restored up on backtracking. The recursion terminates when no valid operations remain, indicating the curent player loses. Otherwise, the function returns true if either operation places the opponent in a losing position.

Complexity Analysis: The state space forms a binary tree with depth at most $d \approx 10$, resulting in approximately $O(2^d)$ node evaluations. Given the constraints $1 \leq x, y \leq 1000$, this operates efficiently within time limits. The space complexity is $O(d)$ for the recursion stack plus $O(1000)$ for the visitation tracking array.

Implementation 1: Separate Player Functions

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

const int MAX_VAL = 1000;
bool used[MAX_VAL + 1];

bool evaluateSecond(int a, int b);

bool evaluateFirst(int a, int b) {
    bool canMove = false;
    bool move1WinsForOpponent = true, move2WinsForOpponent = true;
    
    // Attempt multiplication by 2
    if (a * 2 <= MAX_VAL && !used[a * 2]) {
        canMove = true;
        used[a * 2] = true;
        move1WinsForOpponent = evaluateSecond(a * 2, b);
        used[a * 2] = false;
    }
    
    // Attempt division by 3
    if (a % 3 == 0 && !used[a / 3]) {
        canMove = true;
        used[a / 3] = true;
        move2WinsForOpponent = evaluateSecond(a / 3, b);
        used[a / 3] = false;
    }
    
    if (!canMove) return false;
    // Current player wins if not all moves let opponent win
    return !(move1WinsForOpponent && move2WinsForOpponent);
}

bool evaluateSecond(int a, int b) {
    bool canMove = false;
    bool move1WinsForOpponent = true, move2WinsForOpponent = true;
    
    if (b * 2 <= MAX_VAL && !used[b * 2]) {
        canMove = true;
        used[b * 2] = true;
        move1WinsForOpponent = evaluateFirst(a, b * 2);
        used[b * 2] = false;
    }
    
    if (b % 3 == 0 && !used[b / 3]) {
        canMove = true;
        used[b / 3] = true;
        move2WinsForOpponent = evaluateFirst(a, b / 3);
        used[b / 3] = false;
    }
    
    if (!canMove) return false;
    return !(move1WinsForOpponent && move2WinsForOpponent);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t, x, y;
    cin >> t;
    while (t--) {
        memset(used, 0, sizeof used);
        cin >> x >> y;
        cout << (evaluateFirst(x, y) ? "First" : "Second") << '\n';
    }
    return 0;
}

Implementation 2: Unified Turn-Based Function

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

const int LIMIT = 1000;
bool occupied[LIMIT + 1];
int values[2];

bool canWin(int turn) {
    bool hasOption = false;
    bool opt1OpponentWins = true, opt2OpponentWins = true;
    int &current = values[turn];
    
    // Generate move: multiply by 2
    if (current * 2 <= LIMIT && !occupied[current * 2]) {
        hasOption = true;
        current *= 2;
        occupied[current] = true;
        opt1OpponentWins = canWin(turn ^ 1);
        occupied[current] = false;
        current /= 2;
    }
    
    // Generate move: divide by 3
    if (current % 3 == 0 && !occupied[current / 3]) {
        hasOption = true;
        current /= 3;
        occupied[current] = true;
        opt2OpponentWins = canWin(turn ^ 1);
        occupied[current] = false;
        current *= 3;
    }
    
    if (!hasOption) return false; // Terminal loss
    // Win if any move forces opponent into losing state
    return !opt1OpponentWins || !opt2OpponentWins;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t, x, y;
    cin >> t;
    while (t--) {
        memset(occupied, 0, sizeof occupied);
        cin >> x >> y;
        values[0] = x;
        values[1] = y;
        cout << (canWin(0) ? "First" : "Second") << '\n';
    }
    return 0;
}