# include <cstdlib>
# include <tuple>
# include <type_traits>
# include <cassert>
# include <vector>
# include <algorithm>
# include <numeric>
# include <cstdio>
# include <iostream>
# include <istream>
# include <ostream>

namespace khin {
  using namespace std;
  namespace main {
    inline namespace source {
      template <typename T, enable_if_t<is_signed_v<T>, int> = 0>
        int sgn(T const value) { return (value > 0) - (value < 0); }
    }
    namespace a { void main(); }
    namespace b { void main(); }
    namespace c { void main(); }
    namespace d { void main(); }
    namespace e { void main(); }
  }
}

int main() { khin::main::e::main(); }

namespace khin::main::e {
  namespace test_case {
    struct vector {
      long x, y;
      constexpr vector() : x(), y() {}
      explicit constexpr vector(long const x, long const y) : x(x), y(y) {}
      constexpr vector operator+() const { return vector(+x, +y); }
      constexpr vector operator-() const { return vector(-x, -y); }
      constexpr friend vector operator+(vector const u, vector const v)
      { return vector(u.x + v.x, u.y + v.y); }
      constexpr friend vector operator-(vector const u, vector const v)
      { return vector(u.x - v.x, u.y - v.y); }
      constexpr friend long operator*(vector const u, vector const v)
      { return u.x * v.y - u.y * v.x; }
    } typedef point;
    constexpr uint n_max(3'000);
    uint n; point p[n_max + 1]; std::vector<uint> s, t;
    std::vector<tuple<uint, uint, uint>> ans;
    void main(ushort const x) {
      cin >> n;
      for (uint i(1); i <= n; ++i) cin >> p[i].x >> p[i].y;
      s.resize(n), iota(s.begin(), s.end(), 1u);
      while (s.size() >= 3) {
        uint a, b, c; decltype(s)::iterator it;
        auto const cmp0 = [] (uint const i, uint const j)
        { return make_pair(p[i].x, p[i].y) < make_pair(p[j].x, p[j].y); };
        auto const cmp1 = [&a] (uint const i, uint const j) {
          vector const u(p[i] - p[a]), v(p[j] - p[a]);
          if (u * v) return u * v > 0;
          else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
        };
        auto const cmp2 = [&b] (uint const i, uint const j) {
          vector const u(p[i] - p[b]), v(p[j] - p[b]);
          if (u * v) return u * v < 0;
          else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
        };
        a = *(it = min_element(s.begin(), s.end(), cmp0)), s.erase(it);
        b = *(it = min_element(s.begin(), s.end(), cmp1)), s.erase(it);
        c = *(it = min_element(s.begin(), s.end(), cmp2)), s.erase(it);
        if ((p[a] - p[b]) * (p[b] - p[c])) ans.emplace_back(a, b, c);
        else { s.push_back(a), s.push_back(b), s.push_back(c); break; }
      }
      while (s.size() % 3) s.pop_back();
      /* fprintf(stderr, "%s %u (%zu)\n", __func__, __LINE__, ans.size()); */
      if (!s.empty()) {
        /*
           fprintf(stderr, "%s %u ", __func__, __LINE__);
           fprintf(stderr, "(%zu) ", ans.size());
           fprintf(stderr, "(%zu %zu)\n", s.size(), t.size());
         */
        while (2 * t.size() < s.size() && !ans.empty()) {
          auto const [a, b, c](ans.back()); ans.pop_back();
          ((p[a] - p[s[0]]) * (p[a] - p[s[1]]) ? t : s).push_back(a);
          ((p[b] - p[s[0]]) * (p[b] - p[s[1]]) ? t : s).push_back(b);
          ((p[c] - p[s[0]]) * (p[c] - p[s[1]]) ? t : s).push_back(c);
        }
        /*
           fprintf(stderr, "%s %u ", __func__, __LINE__);
           fprintf(stderr, "(%zu) ", ans.size());
           fprintf(stderr, "(%zu %zu)\n", s.size(), t.size());
         */
        while (s.size() > 2 * t.size()) s.pop_back();
        /*
           fprintf(stderr, "%s %u ", __func__, __LINE__);
           fprintf(stderr, "(%zu) ", ans.size());
           fprintf(stderr, "(%zu %zu)\n", s.size(), t.size());
         */
        assert(2 * t.size() == s.size() || 2 * t.size() == s.size() + 3);
        /*
           fprintf(stderr, "%s %u ", __func__, __LINE__);
           fprintf(stderr, "(%zu) ", ans.size());
           fprintf(stderr, "(%zu %zu)\n", s.size(), t.size());
         */
        if (s.empty() && !t.empty())
          ans.emplace_back(t[0], t[1], t[2]), t.clear();
        [] {
          auto const comp = [] (uint const i, uint const j)
          { return make_pair(p[i].x, p[i].y) < make_pair(p[j].x, p[j].y); };
          sort(s.begin(), s.end(), comp);
        } ();
        if (!s.empty()) {
          vector const d(p[s[1]] - p[s[0]]);
          for (uint const i : s) assert(!((p[i] - p[s.back()]) * d));
          for (uint const i : t) assert( ((p[i] - p[s.back()]) * d));
          while (assert(s.empty() == t.empty()), !s.empty()) {
            assert(2 * t.size() == s.size() || 2 * t.size() == s.size() + 3);
            if (2 * t.size() == s.size()) {
              uint const a(s.back()); s.pop_back();
              uint const b(s.back()); s.pop_back();
              auto const comp = [&b, d] (uint const i, uint const j) {
                vector const u(p[i] - p[b]); assert(u * d);
                vector const v(p[j] - p[b]); assert(v * d);
                if (sgn(u * d) != sgn(v * d)) return sgn(u * d) < sgn(v * d);
                else if (u * v) return sgn(u * d) * (u * v) < 0;
                else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
              };
              auto const it(min_element(t.begin(), t.end(), comp));
              uint const c(*it); t.erase(it);
              assert((p[a] - p[b]) * (p[b] - p[c]));
              ans.emplace_back(a, b, c);
              continue;
            }
            if (s.size() == 1) {
              /* fprintf(stderr, "case %s %u\n", __func__, __LINE__); */
              assert(t.size() == 2);
              ans.emplace_back(s[0], t[0], t[1]);
              s.clear(), t.clear();
              continue;
            }
            uint pos(0), neg(0);
            for (uint const i : t) switch (sgn((p[i] - p[s.back()]) * d)) {
              case +1: ++pos; break;
              case -1: ++neg; break;
              default: assert(false);
            }
            if (pos && pos == min(pos, neg)) {
              [d] {
                uint const a(s.back()); s.pop_back();
                uint const b(s.back()); s.pop_back();
                auto const comp = [&b, d] (uint const i, uint const j) {
                  vector const u(p[i] - p[b]); assert(u * d);
                  vector const v(p[j] - p[b]); assert(v * d);
                  if (sgn(u * d) != sgn(v * d)) return u * d > v * d;
                  else if (u * v) return sgn(u * d) * (u * v) < 0;
                  else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
                };
                auto const it(min_element(t.begin(), t.end(), comp));
                uint const c(*it); t.erase(it);
                assert((p[a] - p[b]) * (p[b] - p[c]));
                ans.emplace_back(a, b, c);
              } ();
              continue;
            }
            if (neg && neg == min(pos, neg)) {
              [d] {
                uint const a(s.back()); s.pop_back();
                uint const b(s.back()); s.pop_back();
                auto const comp = [&b, d] (uint const i, uint const j) {
                  vector const u(p[i] - p[b]); assert(u * d);
                  vector const v(p[j] - p[b]); assert(v * d);
                  if (sgn(u * d) != sgn(v * d)) return u * d < v * d;
                  else if (u * v) return sgn(u * d) * (u * v) < 0;
                  else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
                };
                auto const it(min_element(t.begin(), t.end(), comp));
                uint const c(*it); t.erase(it);
                assert((p[a] - p[b]) * (p[b] - p[c]));
                ans.emplace_back(a, b, c);
              } ();
              continue;
            }
            if (pos && neg) {
              uint const a(s.back()); s.pop_back();
              auto const cmp0 = [&a, d] (uint const i, uint const j) {
                vector const u(p[i] - p[a]); assert(u * d);
                vector const v(p[j] - p[a]); assert(v * d);
                if (sgn(u * d) != sgn(v * d)) return sgn(u * d) > sgn(v * d);
                else if (u * v) return sgn(u * d) * (u * v) < 0;
                else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
              };
              auto const cmp1 = [&a, d] (uint const i, uint const j) {
                vector const u(p[i] - p[a]); assert(u * d);
                vector const v(p[j] - p[a]); assert(v * d);
                if (sgn(u * d) != sgn(v * d)) return sgn(u * d) < sgn(v * d);
                else if (u * v) return sgn(u * d) * (u * v) < 0;
                else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
              };
              decltype(t)::iterator it;
              uint const b(*(it = min_element(t.begin(), t.end(), cmp0)));
              t.erase(it);
              uint const c(*(it = min_element(t.begin(), t.end(), cmp1)));
              t.erase(it);
              ans.emplace_back(a, b, c);
              assert((p[a] - p[b]) * (p[b] - p[c]));
              continue;
            }
            if (s.size() > 3) {
              uint const a(s.back()); s.pop_back();
              uint const b(s.back()); s.pop_back();
              auto const comp = [&b, d] (uint const i, uint const j) {
                vector const u(p[i] - p[b]); assert(u * d);
                vector const v(p[j] - p[b]); assert(v * d);
                if (u * v) return sgn(u * d) * (u * v) < 0;
                else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
              };
              auto const it(min_element(t.begin(), t.end(), comp));
              uint const c(*it); t.erase(it);
              ans.emplace_back(a, b, c);
              continue;
            }
            assert(s.size() == 3), assert(t.size() == 3);
            auto const chk0 = [d] {
              auto const comp = [d] (uint const i, uint const j) {
                vector const u(p[i] - p[s[0]]); assert(u * d);
                vector const v(p[j] - p[s[0]]); assert(v * d);
                return sgn(u * d) * (u * v) > 0;
              };
              sort(t.begin(), t.end(), comp);
              return comp(t[0], t[1]);
            };
            auto const chk1 = [d] {
              auto const comp = [d] (uint const i, uint const j) {
                vector const u(p[i] - p[s[2]]); assert(u * d);
                vector const v(p[j] - p[s[2]]); assert(v * d);
                return sgn(u * d) * (u * v) < 0;
              };
              sort(t.begin(), t.end(), comp);
              return comp(t[0], t[1]);
            };
            if (chk0()) {
              /* fprintf(stderr, "case %s %u\n", __func__, __LINE__); */
              ans.emplace_back(s[0], t[0], t[1]);
              ans.emplace_back(s[1], s[2], t[2]);
              s.clear(), t.clear();
              continue;
            }
            if (chk1()) {
              /* fprintf(stderr, "case %s %u\n", __func__, __LINE__); */
              ans.emplace_back(s[2], t[0], t[1]);
              ans.emplace_back(s[1], s[0], t[2]);
              s.clear(), t.clear();
              continue;
            }
            /* fprintf(stderr, "case %s %u\n", __func__, __LINE__); */
            auto const comp = [d] (uint const i, uint const j) {
              vector const u(p[i] - p[s[0]]); assert(u * d);
              vector const v(p[j] - p[s[0]]); assert(v * d);
              if (u * v) return sgn(u * d) * (u * v) > 0;
              else return abs(u.x) + abs(u.y) < abs(v.x) + abs(v.y);
            };
            sort(t.begin(), t.end(), comp);
            ans.emplace_back(s[0], s[2], t[1]);
            ans.emplace_back(s[1], t[0], t[2]);
            s.clear(), t.clear();
            continue;
          }
        }
      }
      assert(s.empty()), assert(t.empty());
      printf("Case #%hu: %zu\n", x, ans.size());
      for (auto const [p, q, r] : ans) printf("%u %u %u\n", p, q, r);
      ans.clear();
    }
  }
  void main() {
    ushort t; cin >> t;
    for (ushort i(1); i <= t; ++i) test_case::main(i);
  }
}