#include <iostream>
#include <cstdint>
#include <vector>
#include <format>
#include <stdexcept>
#include <algorithm>
#include <iterator>
#include <optional>
#include <random>
#include <ranges>
#include <array>
#include <compare>
 
using Coordinate = uint32_t;
using NumberOfChips = uint32_t;
using NumberOfBlocks = uint32_t;
using TotalNumberOfChips = uint64_t;
using SignedTotalCoordinate = int32_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::strong_ordering operator<=>(const Cell other) const {
        if (coordinate != other.coordinate || number_of_chips == other.number_of_chips && color == other.color)
            return coordinate <=> other.coordinate;
        else
            return std::strong_ordering::equivalent;
    }
    bool operator==(const Cell& other) const = default;
};
 
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;
}
 
namespace solution {
    struct TwoChipsAdvancement {
        Coordinate positive_coordinate, negative_coordinate;
        bool positive_over, negative_over, chip_inequality;
        SignedTotalCoordinate delta;
    };
 
    template <class T, Color COLOR>
    struct TwoChipsIterator {
        using difference_type = std::make_signed_t<Coordinate>;
        using value_type = TwoChipsAdvancement;
        T::const_iterator positive_iterator, negative_iterator,
                             end_positive_iterator, end_negative_iterator;
        NumberOfChips remaining_positive_chips, remaining_negative_chips;
        bool halt;
 
        bool saw_chip_inequality() const {
            bool positive_over = positive_iterator == end_positive_iterator;
            bool negative_over = negative_iterator == end_negative_iterator;
            bool bigger_positive = negative_over && remaining_positive_chips > 0;
            bool bigger_negative = positive_over && remaining_negative_chips > 0;
            return bigger_positive || bigger_negative;
        }
 
        TwoChipsAdvancement operator*() const {
            bool positive_over = positive_iterator == end_positive_iterator;
            bool negative_over = negative_iterator == end_negative_iterator;
            Coordinate positive_coordinate = !positive_over ? positive_iterator->coordinate : 0;
            Coordinate negative_coordinate = !negative_over ? negative_iterator->coordinate : 0;
            return {
                .positive_coordinate = positive_coordinate,
                .negative_coordinate = negative_coordinate,
                .positive_over = positive_over,
                .negative_over = negative_over,
                .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_iterator == other.positive_iterator &&
                   negative_iterator == other.negative_iterator &&
                   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_iterator != end_positive_iterator) {
                remaining_negative_chips -= remaining_positive_chips;
                remaining_positive_chips = 0;
                ++positive_iterator;
                if (positive_iterator != end_positive_iterator && positive_iterator->color == COLOR)
                    remaining_positive_chips = positive_iterator->number_of_chips;
            } else if (remaining_negative_chips <= remaining_positive_chips && negative_iterator != end_negative_iterator) {
                remaining_positive_chips -= remaining_negative_chips;
                remaining_negative_chips = 0;
                ++negative_iterator;
                if (negative_iterator != end_negative_iterator && negative_iterator->color != COLOR)
                    remaining_negative_chips = negative_iterator->number_of_chips;
            } else
                halt = true;
            return *this;
        }
 
        TwoChipsIterator operator++(int) {
            TwoChipsIterator other = *this;
            ++*this;
            return other;
        }
    };
 
    template<class T, Color COLOR>
    struct ColoredChipStorage {
        const T& cells;
 
        ColoredChipStorage(const T& container) : cells(container) {}
 
        TwoChipsIterator<T, COLOR> begin() const {
            return {
                    .positive_iterator = cells.cbegin(),
                    .negative_iterator = cells.cbegin(),
                    .end_positive_iterator = cells.cend(),
                    .end_negative_iterator = cells.cend(),
                    .remaining_positive_chips = cells.begin() != cells.end() && cells.begin()->color == COLOR
                                                ? cells.begin()->number_of_chips : 0,
                    .remaining_negative_chips = cells.begin() != cells.end() && cells.begin()->color != COLOR
                                                ? cells.begin()->number_of_chips : 0,
                    .halt = false,
            };
        }
 
        TwoChipsIterator<T, COLOR> end() const {
            return {
                    .positive_iterator = cells.cend(),
                    .negative_iterator = cells.cend(),
                    .end_positive_iterator = cells.cend(),
                    .end_negative_iterator = cells.cend(),
                    .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(Test test) {
        std::ranges::sort(test.cells, std::ranges::greater());
        ColoredChipStorage<std::vector<Cell>, RED> red_chips(test.cells);
        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, .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"}
    );
}
