#include <iostream>
#include <cstdint>
#include <vector>
#include <format>
#include <stdexcept>
#include <algorithm>
#include <iterator>
#include <optional>
#include <random>
#include <ranges>
#include <array>
 
using Coordinate = uint32_t;
using NumberOfChips = uint32_t;
using NumberOfBlocks = uint32_t;
using TotalNumberOfChips = uint64_t;
using SignedTotalCoordinate = int64_t;
 
enum Color {
    RED, BLUE
};
 
std::istream &operator>>(std::istream &in, Color &color) {
    std::string color_str;
    in >> color_str;
    if (color_str == "R")
        color = RED;
    else
        color = BLUE;
    return in;
}
 
struct Cell {
    Coordinate coordinate;
    NumberOfChips number_of_chips;
    Color color;
};
 
std::istream &operator>>(std::istream &in, Cell &cell) {
    return in >> cell.coordinate >> cell.number_of_chips >> cell.color;
}
 
struct Test {
    std::vector<Cell> cells;
};
 
std::istream &operator>>(std::istream &in, Test &test) {
    NumberOfBlocks n;
    in >> n;
    test.cells.assign(n, {});
    std::copy_n(std::istream_iterator<Cell>(in), n, test.cells.begin());
    return in;
}
 
enum Direction {
    LEFT, SKIP, RIGHT
};
 
std::ostream &operator<<(std::ostream &out, const Direction direction) {
    if (direction == LEFT)
        out << '-';
    else if (direction == SKIP)
        out << '0';
    else
        out << '+';
    return out;
}
 
struct Move {
    Coordinate coordinate;
    Direction direction;
};
 
std::ostream &operator<<(std::ostream &out, const Move move) {
    return out << move.coordinate << ' ' << move.direction;
}
 
struct Verdict {
    bool first_wins;
    Move move;
};
 
std::string shuffle_cases(std::string str) {
    static std::mt19937 rng;
    std::ranges::transform(str.begin(), str.end(), str.begin(), [](char c) -> char {
        if (std::uniform_int_distribution<uint8_t>(false, true)(rng))
            return static_cast<char>(std::tolower(c));
        else
            return static_cast<char>(std::toupper(c));
    });
    return str;
}
 
std::ostream &operator<<(std::ostream &out, const Verdict verdict) {
    return out << shuffle_cases(verdict.first_wins ? "First" : "Draw") << ' ' << verdict.move;
}
 
struct Answer {
    std::optional<Verdict> verdict;
};
 
std::ostream &operator<<(std::ostream &out, const Answer answer) {
    if (answer.verdict)
        out << *answer.verdict;
    else
        out << shuffle_cases("Second");
    return out;
}
 
static const Coordinate MAX_COORDINATE = 1'000'000;
 
namespace solution {
    struct TwoChipsAdvancement {
        Coordinate positive_coordinate, negative_coordinate;
        bool positive_over, negative_over, chip_inequality;
        SignedTotalCoordinate delta;
    };
 
    template<class T>
    struct TwoChipsIterator {
        using difference_type = std::make_signed_t<Coordinate>;
        using value_type = TwoChipsAdvancement;
        const T *quantity;
        Coordinate positive_coordinate, negative_coordinate;
        NumberOfChips remaining_positive_chips, remaining_negative_chips;
        bool halt;
 
        bool saw_chip_inequality() const {
            bool bigger_positive = positive_coordinate == 0 && remaining_negative_chips > 0;
            bool bigger_negative = negative_coordinate == 0 && remaining_positive_chips > 0;
            return bigger_positive || bigger_negative;
        }
 
        TwoChipsAdvancement operator*() const {
            return {.positive_coordinate = positive_coordinate, .negative_coordinate = negative_coordinate, .positive_over =
            positive_coordinate == 0, .negative_over = negative_coordinate == 0, .chip_inequality = saw_chip_inequality(), .delta =
            (static_cast<SignedTotalCoordinate>(positive_coordinate) - static_cast<SignedTotalCoordinate>(negative_coordinate)) *
            std::min(remaining_positive_chips, remaining_negative_chips)};
        }
 
        bool operator==(const TwoChipsIterator &other) const {
            if (halt || other.halt)
                return halt == other.halt;
            return positive_coordinate == other.positive_coordinate &&
                   negative_coordinate == other.negative_coordinate &&
                   remaining_positive_chips == other.remaining_positive_chips &&
                   remaining_negative_chips == other.remaining_negative_chips;
        }
 
        TwoChipsIterator &operator++() {
            if (halt)
                throw std::runtime_error("Cannot increment a finished iterator");
            if (remaining_positive_chips <= remaining_negative_chips && positive_coordinate > 0) {
                remaining_negative_chips -= remaining_positive_chips;
                remaining_positive_chips = std::max(0, (*quantity)[--positive_coordinate]);
            } else if (remaining_negative_chips <= remaining_positive_chips && negative_coordinate > 0) {
                remaining_positive_chips -= remaining_negative_chips;
                remaining_negative_chips = std::max(0, -(*quantity)[--negative_coordinate]);
            } else
                halt = true;
            return *this;
        }
 
        TwoChipsIterator operator++(int) {
            TwoChipsIterator other = *this;
            ++*this;
            return other;
        }
    };
 
    template<Color COLOR>
    struct ColoredChipStorage {
        using SignedNumberOfChips = std::make_signed_t<NumberOfChips>;
        using Storage = std::vector<SignedNumberOfChips>;
        Storage quantity;
        uint32_t min_coordinate_m1;
 
        ColoredChipStorage(const uint32_t min_coordinate, const uint32_t max_coordinate) : quantity(max_coordinate - min_coordinate + 2), min_coordinate_m1(min_coordinate - 1) {
        }
 
        ColoredChipStorage operator+(const Cell cell) &&{
            if (cell.color == COLOR)
                quantity[cell.coordinate - min_coordinate_m1] += cell.number_of_chips;
            else
                quantity[cell.coordinate - min_coordinate_m1] -= cell.number_of_chips;
            return *this;
        }
 
        [[nodiscard]] TwoChipsIterator<Storage> begin() const {
            return {
                    .quantity = &quantity,
                    .positive_coordinate = static_cast<Coordinate>(quantity.size() - 1),
                    .negative_coordinate = static_cast<Coordinate>(quantity.size() - 1),
                    .remaining_positive_chips = static_cast<NumberOfChips>(std::max<SignedNumberOfChips>(
                            0,
                            quantity.back())),
                    .remaining_negative_chips = static_cast<NumberOfChips>(-std::min<SignedNumberOfChips>(
                            0, quantity.back())),
                    .halt = false,
            };
        }
 
        [[nodiscard]] TwoChipsIterator<Storage> end() const {
            return {
                    .quantity = &quantity,
                    .positive_coordinate = 0,
                    .negative_coordinate = 0,
                    .remaining_positive_chips = 0,
                    .remaining_negative_chips = 0,
                    .halt = true,
            };
        }
    };
 
    struct ColoredSuffixInfo {
        SignedTotalCoordinate current_balance = 0;
        bool more_positive = false, more_negative = false, seen_positive_suffix = false, seen_strictly_negative_suffix = false;
        Coordinate maximum_positive_coordinate_chip = 0;
 
        ColoredSuffixInfo operator+(const TwoChipsAdvancement two_chips_advancement) &&{
            more_positive = two_chips_advancement.negative_over && two_chips_advancement.chip_inequality;
            more_negative = two_chips_advancement.positive_over && two_chips_advancement.chip_inequality;
            current_balance += two_chips_advancement.delta;
            if (two_chips_advancement.delta != 0)
                maximum_positive_coordinate_chip = std::max(maximum_positive_coordinate_chip,
                                                            two_chips_advancement.positive_coordinate);
            if (current_balance >= 1)
                seen_positive_suffix = true;
            if (current_balance <= -2)
                seen_strictly_negative_suffix = true;
            return *this;
        }
    };
 
    Answer find_answer(const Test &test) {
        uint32_t min_coordinate = std::ranges::min_element(test.cells, std::ranges::less(), [](const Cell cell){ return cell.coordinate;})->coordinate;
        uint32_t max_coordinate = std::ranges::min_element(test.cells, std::ranges::greater(), [](const Cell cell){ return cell.coordinate;})->coordinate;
        ColoredChipStorage<RED> red_chips = std::ranges::fold_left(test.cells,
                                                                   ColoredChipStorage<RED>(min_coordinate, max_coordinate),
                                                                   std::plus());
        ColoredSuffixInfo analysis_result = std::ranges::fold_left(red_chips, ColoredSuffixInfo{}, std::plus());
        if (analysis_result.more_negative && !analysis_result.seen_positive_suffix)
            return {};
        return {.verdict = Verdict{.first_wins = !analysis_result.seen_strictly_negative_suffix &&
                                                 analysis_result.more_positive, .move = {.coordinate = analysis_result.maximum_positive_coordinate_chip + red_chips.min_coordinate_m1, .direction = Direction::RIGHT}}};
    }
}
 
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    uint32_t t;
    std::cin >> t;
    std::vector<Test> tests(t);
    std::copy_n(std::istream_iterator<Test>(std::cin), t, tests.begin());
    std::ranges::copy(
            std::views::transform(tests, solution::find_answer),
            std::ostream_iterator<Answer>{std::cout, "\n"}
    );
}
