#include <bits/stdc++.h>
using namespace std;
ifstream f("triangulare.in");
ofstream g("triangulare.out");
class Point {
  public:
    int x, y;
    Point(const int _x = 0, const int _y = 0):
      x(_x),
      y(_y) {}
    bool operator==(const Point &other) const {
        return (x == other.x && y == other.y);
    }
};
inline int Det(const Point &p1, const Point &p2, const Point &p3) {
    return p1.x * p2.y + p2.x * p3.y + p3.x * p1.y - p1.x * p3.y - p2.x * p1.y - p3.x * p2.y;
}
class Segment {
  public:
    Point e1, e2;

    Segment(const Point _e1, const Point _e2):
      e1(_e1),
      e2(_e2) {
        if (e1.y > e2.y)
            swap(e1, e2);
    }

    static bool OpenIntersection(const Segment &s1, const Segment &s2) {
        if (s1.e1 == s1.e2 || s2.e1 == s2.e2)
            return false;
        if (Det(s1.e1, s1.e2, s2.e1) == 0 && Det(s1.e1, s1.e2, s2.e2) == 0) {
            if (OpenIntervalIntersection(s1.e1.x, s1.e2.x, s2.e1.x, s2.e2.x))
                return true;
            if (OpenIntervalIntersection(s1.e1.y, s1.e2.y, s2.e1.y, s2.e2.y))
                return true;
            return false;
        }
        return (1LL * Det(s1.e1, s1.e2, s2.e1) * Det(s1.e1, s1.e2, s2.e2) < 0 && 1LL * Det(s2.e1, s2.e2, s1.e1) * Det(s2.e1, s2.e2, s1.e2) < 0);
    }

  private:
    static bool OpenIntervalIntersection(int x1, int x2, int y1, int y2) {
        if (x1 > x2)
            swap(x1, x2);
        if (y1 > y2)
            swap(y1, y2);
        if (x1 > y1) {
            swap(x1, y1);
            swap(x2, y2);
        }
        return y1 < x2;
    }
};
class Polygon {
  public:
    vector<Segment> edges;

    Polygon():
      edges(vector<Segment>()) {}

    Polygon(const vector<Point> &points) {
        int sf=points.size();
        for (int i = 0; i < sf; ++i)
            edges.push_back(Segment(points[i], points[(i + 1) %sf]));
    }

    bool IsInside(const Point &p) const {
        int intersect = 0;
        for (const auto &segment: edges)
            if (segment.e1.y < p.y && p.y <= segment.e2.y && Det(segment.e1, segment.e2, p) < 0)
                ++intersect;
        return intersect&1;
    }
};
vector<Point> Points;
Polygon P;
int N;
vector< pair<int, int> > Triangulation;
inline bool CheckSegment(const Segment &edge) {
    for (const auto &e: P.edges)
        if (Segment::OpenIntersection(e, edge))
            return false;
    for (const auto &e: Triangulation)
        if (Segment::OpenIntersection(Segment(Points[e.first], Points[e.second]), edge))
            return false;
    return P.IsInside(Point((edge.e1.x + edge.e2.x)>>1, (edge.e1.y + edge.e2.y)>>1));
}
void Solve() {
    Triangulation = vector< pair<int, int> >();
    for (int i = 0; i < N; ++i)
        for (int j = (i + 2) % N; (j + 1) % N != i; j = (j + 1) % N)
            if (CheckSegment(Segment(Points[i], Points[j])))
                Triangulation.push_back(make_pair(i, j));
    sort(Triangulation.begin(), Triangulation.end());
}
void Read() {
    f>>N;
    Points = vector<Point>(N);
    for (int i = 0; i < N; ++i) {
        f>>Points[i].x>>Points[i].y;
        Points[i].x<<=1;
        Points[i].y<<=1;
    }
    P = Polygon(Points);
}
void Print() {
    for (const auto &segment: Triangulation)
        g<<segment.first<<' '<<segment.second<<'\n';
}
int main() {
    int t;
    f>>t;
    while(t--) {
        Read();
        Solve();
        Print();
    }
    return 0;
}