#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

struct Node {
    int x;
    int y;
    bool victory;
    vector<Node> children;
    bool operator()(const Node& n1, const Node& n2) {
        if(n1.x == n2.x) {
            return n1.y < n2.y;
        }

        return n1.x < n2.x;
    }
};

bool isGoal(Node& n) {
    if((n.x == 1 || n.x == 2) && (n.y == 1 || n.y == 2)) {
        return true;
    }
    return false;
}
size_t nodeCount = 0;
void extract(Node& act) {

    for(int i = 0; i < 4; ++i) {
        int xX = act.x;
        int yY = act.y;
        switch(i) {
            case 0: xX -= 2; yY -= 1; break;
            case 1: xX -= 2; yY += 1; break;
            case 2: xX += 1; yY -= 2; break;
            case 3: xX -= 1; yY -= 2; break;
        }
        if(!(xX <= 0 || xX > 15 || yY <= 0 || yY > 15)) {

            Node n{xX, yY, false};
            act.children.push_back(n);
            ++nodeCount;
        }
    }
}

void traversal(Node& act) {
    extract(act);
    for(size_t i = 0; i < act.children.size(); ++i) {
        traversal(act.children[i]);
    }
}

void markGoals(Node& node, int level = 0) {
    for(size_t i = 0; i < node.children.size(); ++i) {
        markGoals(node.children[i], level + 1);
    }

    if(node.children.size() == 0) {
        if((level % 2) == 0) {
            node.victory = false; 
        } else {
            node.victory = true; 
        }
    } else {
        if((level % 2) == 0) {

            for(size_t i = 0; i < node.children.size(); ++i) {
                if(node.children[i].victory) {
                    node.victory = true;
                    break;
                }
            }
        } else {

            size_t victories = 0;
            for(size_t i = 0; i < node.children.size(); ++i) {
                if(node.children[i].victory) {
                    ++victories;
                }
            }
            if(victories == node.children.size()) {
                node.victory = true;
            }
        }
    }
}

void printNode(Node& node, int level = 0) {
    cout << string(level, '-') << "victory: " << node.victory;
    cout << " children count: " << node.children.size() << "\n";
    cout << string(level, '-') << "x: " << node.x << " y: " << node.y;
    cout << "\n";
}

void printTree(Node& node, int level = 0) {
    printNode(node, level);
    for(size_t i = 0; i < node.children.size(); ++i) {
        printTree(node.children[i], level + 2);
    }
}

struct Node2 {
    int x;
    int y;
    bool victory;
    bool touched;
    vector<int> children;
};

void extract2(Node2& act) {

    for(int i = 0; i < 4; ++i) {
        int xX = act.x;
        int yY = act.y;
        switch(i) {
            case 0: xX -= 2; yY -= 1; break;
            case 1: xX -= 2; yY += 1; break;
            case 2: xX += 1; yY -= 2; break;
            case 3: xX -= 1; yY -= 2; break;
        }
        if(!(xX < 0 || xX >= 15 || yY < 0 || yY >= 15)) {

            act.children.push_back(yY * 15 + xX);
        }
    }
}

vector<Node2> availableNodes(225);
void prepareAvailableNodes() {
    for(int i = 0; i < 15; ++i) {
        for(int j = 0; j < 15; ++j) {
            availableNodes[i * 15 + j].x = i;
            availableNodes[i * 15 + j].y = j;
            availableNodes[i * 15 + j].victory = false;
            availableNodes[i * 15 + j].touched = false;
            extract2(availableNodes[i * 15 + j]);
        }
    }
}

void markGoals2(Node2& node, int level = 0) {
    if(node.touched) {
        return;
    }

    node.touched = true;

    for(size_t i = 0; i < node.children.size(); ++i) {
        Node2& n = availableNodes[node.children[i]];
        markGoals2(n, level + 1);
    }

    if(node.children.size() == 0) {
        if((level % 2) == 0) {
            node.victory = false; 
        } else {
            node.victory = true; 
        }
    } else {
        if((level % 2) == 0) {

            for(size_t i = 0; i < node.children.size(); ++i) {
                Node2& n = availableNodes[node.children[i]];
                if(n.victory) {
                    node.victory = true;
                    break;
                }
            }
        } else {

            size_t victories = 0;
            for(size_t i = 0; i < node.children.size(); ++i) {
                Node2& n = availableNodes[node.children[i]];
                if(n.victory) {
                    ++victories;
                }
            }
            if(victories == node.children.size()) {
                node.victory = true;
            }
        }
    }
}

string chessboardGame(int x, int y) {

    Node2& root = availableNodes[(y - 1) * 15 + x - 1];

    prepareAvailableNodes();

    markGoals2(root);

    cerr << "x: " << x << " y: " << y << endl;
    return root.victory ? "First" : "Second";
}

string chessboardGame_(int x, int y) {
    x=x%4; 
    y=y%4;
    if((y==0)||(y==3)||(x==0)||(x==3)) return "First";
    return "Second";
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    int t;
    cin >> t;
    cin.ignore(numeric_limits<streamsize>::max(), '\n');

    for (int t_itr = 0; t_itr < t; t_itr++) {
        string xy_temp;
        getline(cin, xy_temp);

        vector<string> xy = split_string(xy_temp);

        int x = stoi(xy[0]);

        int y = stoi(xy[1]);

        string result = chessboardGame(x, y);

        fout << result << "\n";
    }

    fout.close();

    return 0;
}

vector<string> split_string(string input_string) {
    string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
        return x == y and x == ' ';
    });

    input_string.erase(new_end, input_string.end());

    while (input_string[input_string.length() - 1] == ' ') {
        input_string.pop_back();
    }

    vector<string> splits;
    char delimiter = ' ';

    size_t i = 0;
    size_t pos = input_string.find(delimiter);

    while (pos != string::npos) {
        splits.push_back(input_string.substr(i, pos - i));

        i = pos + 1;
        pos = input_string.find(delimiter, i);
    }

    splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

    return splits;
}
#include <bits/stdc++.h>

/*
example input:

XXXXXX-XXX
XX------XX
XXXXXX-XXX
XXXXXX-XXX
XXX------X
XXXXXX-X-X
XXXXXX-X-X
XXXXXXXX-X
XXXXXXXX-X
XXXXXXXX-X
ICELAND;MEXICO;PANAMA;ALMATY

*/

using namespace std;

vector<string> split_string(string);

struct Node {
    int x;
    int y;
    bool victory;
    vector<Node> children;
    bool operator()(const Node& n1, const Node& n2) {
        if(n1.x == n2.x) {
            return n1.y < n2.y;
        }

        return n1.x < n2.x;
    }
};

bool isGoal(Node& n) {
    if((n.x == 1 || n.x == 2) && (n.y == 1 || n.y == 2)) {
        return true;
    }
    return false;
}
size_t nodeCount = 0;
void extract(Node& act) {
    //cout << "extract: x: " << act.x << " y: " << act.y << endl;
    for(int i = 0; i < 4; ++i) {
        int xX = act.x;
        int yY = act.y;
        switch(i) {
            case 0: xX -= 2; yY -= 1; break;
            case 1: xX -= 2; yY += 1; break;
            case 2: xX += 1; yY -= 2; break;
            case 3: xX -= 1; yY -= 2; break;
        }
        if(!(xX <= 0 || xX > 15 || yY <= 0 || yY > 15)) {
            //cout << "test: x: " << xX << " y: " << yY << endl;
            Node n{xX, yY, false};
            act.children.push_back(n);
            ++nodeCount;
        }
    }
}

void traversal(Node& act) {
    extract(act);
    for(size_t i = 0; i < act.children.size(); ++i) {
        traversal(act.children[i]);
    }
}

// calculation from the first player's point of view
void markGoals(Node& node, int level = 0) {
    for(size_t i = 0; i < node.children.size(); ++i) {
        markGoals(node.children[i], level + 1);
    }

    if(node.children.size() == 0) {
        if((level % 2) == 0) {
            node.victory = false; // the first one lost
        } else {
            node.victory = true; // the first one won
        }
    } else {
        if((level % 2) == 0) {
            // at least one node had to win
            for(size_t i = 0; i < node.children.size(); ++i) {
                if(node.children[i].victory) {
                    node.victory = true;
                    break;
                }
            }
        } else {
            // all of the nodes had to win
            size_t victories = 0;
            for(size_t i = 0; i < node.children.size(); ++i) {
                if(node.children[i].victory) {
                    ++victories;
                }
            }
            if(victories == node.children.size()) {
                node.victory = true;
            }
        }
    }
}

void printNode(Node& node, int level = 0) {
    cout << string(level, '-') << "victory: " << node.victory;
    cout << " children count: " << node.children.size() << "\n";
    cout << string(level, '-') << "x: " << node.x << " y: " << node.y;
    cout << "\n";
}

void printTree(Node& node, int level = 0) {
    printNode(node, level);
    for(size_t i = 0; i < node.children.size(); ++i) {
        printTree(node.children[i], level + 2);
    }
}

struct Node2 {
    int x;
    int y;
    bool victory;
    bool touched;
    vector<int> children;
};

void extract2(Node2& act) {
    //cout << "extract: x: " << act.x << " y: " << act.y << endl;
    for(int i = 0; i < 4; ++i) {
        int xX = act.x;
        int yY = act.y;
        switch(i) {
            case 0: xX -= 2; yY -= 1; break;
            case 1: xX -= 2; yY += 1; break;
            case 2: xX += 1; yY -= 2; break;
            case 3: xX -= 1; yY -= 2; break;
        }
        if(!(xX < 0 || xX >= 15 || yY < 0 || yY >= 15)) {
            //cout << "test: x: " << xX << " y: " << yY << endl;
            act.children.push_back(yY * 15 + xX);
        }
    }
}

vector<Node2> availableNodes(225);
void prepareAvailableNodes() {
    for(int i = 0; i < 15; ++i) {
        for(int j = 0; j < 15; ++j) {
            availableNodes[i * 15 + j].x = i;
            availableNodes[i * 15 + j].y = j;
            availableNodes[i * 15 + j].victory = false;
            availableNodes[i * 15 + j].touched = false;
            extract2(availableNodes[i * 15 + j]);
        }
    }
}

void markGoals2(Node2& node, int level = 0) {
    if(node.touched) {
        return;
    }
    
    node.touched = true;
    
    for(size_t i = 0; i < node.children.size(); ++i) {
        Node2& n = availableNodes[node.children[i]];
        markGoals2(n, level + 1);
    }

    if(node.children.size() == 0) {
        if((level % 2) == 0) {
            node.victory = false; // the first one lost
        } else {
            node.victory = true; // the first one won
        }
    } else {
        if((level % 2) == 0) {
            // at least one node had to win
            for(size_t i = 0; i < node.children.size(); ++i) {
                Node2& n = availableNodes[node.children[i]];
                if(n.victory) {
                    node.victory = true;
                    break;
                }
            }
        } else {
            // all of the nodes had to win
            size_t victories = 0;
            for(size_t i = 0; i < node.children.size(); ++i) {
                Node2& n = availableNodes[node.children[i]];
                if(n.victory) {
                    ++victories;
                }
            }
            if(victories == node.children.size()) {
                node.victory = true;
            }
        }
    }
}

// Complete the chessboardGame function below.
string chessboardGame(int x, int y) {
    //Node2 root{y, x, false};
    Node2& root = availableNodes[(y - 1) * 15 + x - 1];

    //using namespace std::chrono;
    //auto t0 = high_resolution_clock::now();

    //traversal(root);
    prepareAvailableNodes();
    
    //auto t1 = high_resolution_clock::now();
    //std::cout << std::endl << duration_cast<milliseconds>(t1-t0).count() << " milliseconds passed\n";
    //t0 = t1;

    markGoals2(root);
    
    //t1 = high_resolution_clock::now();
    //std::cout << std::endl << duration_cast<milliseconds>(t1-t0).count() << " milliseconds passed\n";
    
    //printTree(root);
    //cout << nodeCount << "\n";
    cerr << "x: " << x << " y: " << y << endl;
    return root.victory ? "First" : "Second";
}

string chessboardGame_(int x, int y) {
    x=x%4; 
    y=y%4;
    if((y==0)||(y==3)||(x==0)||(x==3)) return "First";
    return "Second";
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    int t;
    cin >> t;
    cin.ignore(numeric_limits<streamsize>::max(), '\n');

    for (int t_itr = 0; t_itr < t; t_itr++) {
        string xy_temp;
        getline(cin, xy_temp);

        vector<string> xy = split_string(xy_temp);

        int x = stoi(xy[0]);

        int y = stoi(xy[1]);

        string result = chessboardGame(x, y);

        fout << result << "\n";
    }

    fout.close();

    return 0;
}

vector<string> split_string(string input_string) {
    string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
        return x == y and x == ' ';
    });

    input_string.erase(new_end, input_string.end());

    while (input_string[input_string.length() - 1] == ' ') {
        input_string.pop_back();
    }

    vector<string> splits;
    char delimiter = ' ';

    size_t i = 0;
    size_t pos = input_string.find(delimiter);

    while (pos != string::npos) {
        splits.push_back(input_string.substr(i, pos - i));

        i = pos + 1;
        pos = input_string.find(delimiter, i);
    }

    splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

    return splits;
}
