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

namespace khin {
  using namespace std;
  namespace main {
    inline namespace source {
      template <typename T, enable_if_t<is_signed<T>::value, int> = 0>
        constexpr 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 {
    constexpr uint n_max(3'000);
    struct vector {
      int x, y;
      constexpr vector() : x(), y() {}
      explicit constexpr vector(int const x, int 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 1l * u.x * v.y - 1l * u.y * v.x; }
    } typedef point;
    constexpr bool comp(vector const u, vector const v) {
      ushort const tu(u.x < 0 ? 0 : u.x == 0 ? u.y < 0 ? 1 : 3 : 2);
      ushort const tv(v.x < 0 ? 0 : v.x == 0 ? v.y < 0 ? 1 : 3 : 2);
      uint const lu(abs(u.x) + abs(u.y)), lv(abs(v.x) + abs(v.y));
      return tu == tv ? u * v ? u * v > 0 : lu < lv : tu < tv;
    }
    uint n; point p[n_max + 1]; std::vector<uint> s, t;
    std::vector<tuple<uint, uint, uint>> ans;
    inline void printerr(uint const a, uint const b, uint const c) {
      fprintf(stderr, "(%u, %u) ", p[a].x, p[a].y);
      fprintf(stderr, "(%u, %u) ", p[b].x, p[b].y);
      fprintf(stderr, "(%u, %u)\n", p[c].x, p[c].y);
    }
    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) {
        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); };
        uint const a(*min_element(s.begin(), s.end(), cmp0));
        s.erase(min_element(s.begin(), s.end(), cmp0));
        auto const cmp1 = [&] (uint const i, uint const j) {
          vector const u(p[i] - p[a]), v(p[j] - p[a]);
          ushort const tu(u.x < 0 ? 0 : u.x == 0 ? u.y < 0 ? 1 : 3 : 2);
          ushort const tv(v.x < 0 ? 0 : v.x == 0 ? v.y < 0 ? 1 : 3 : 2);
          uint const lu(abs(u.x) + abs(u.y)), lv(abs(v.x) + abs(v.y));
          return tu == tv ? u * v ? u * v > 0 : lu < lv : tu < tv;
        };
        uint const b(*min_element(s.begin(), s.end(), cmp1));
        s.erase(min_element(s.begin(), s.end(), cmp1));
        auto const cmp2 = [&] (uint const i, uint const j) {
          vector const u(p[b] - p[i]), v(p[b] - p[j]);
          ushort const tu(u.x < 0 ? 0 : u.x == 0 ? u.y < 0 ? 1 : 3 : 2);
          ushort const tv(v.x < 0 ? 0 : v.x == 0 ? v.y < 0 ? 1 : 3 : 2);
          uint const lu(abs(u.x) + abs(u.y)), lv(abs(v.x) + abs(v.y));
          return tu == tv ? u * v ? u * v < 0 : lu < lv : tu > tv;
        };
        uint const c(*min_element(s.begin(), s.end(), cmp2));
        s.erase(min_element(s.begin(), s.end(), cmp2));
        if (!((p[a] - p[b]) * (p[b] - p[c])))
        { s.push_back(a), s.push_back(b), s.push_back(c); break; }
        /* fputs("ins ", stderr), printerr(a, b, c); */
        ans.emplace_back(a, b, c);
      }
      if (s.size() > 1) {
        while (!ans.empty() && 2 * t.size() < s.size()) {
          auto const [a, b, c](ans.back()); ans.pop_back();
          /* fputs("era ", stderr), printerr(a, b, c); */
          ((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);
        }
        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); };
        sort(s.begin(), s.end(), cmp0);
        vector const vs(p[s[1]] - p[s[0]]);
        auto const find = [&] {
          uint const b(s.back());
          auto const comp = [&] (uint const i, uint const j) {
            vector vi(p[i] - p[b]); assert(vi * vs);
            vector vj(p[j] - p[b]); assert(vj * vs);
            if (sgn(vi * vs) != sgn(vj * vs))
              return sgn(vi * vs) > sgn(vj * vs);
            return vi * vj * sgn(vi * vs) < 0;
          };
          auto const it(min_element(t.begin(), t.end(), comp));
          uint const tmp(*it); t.erase(it); return tmp;
        };
        auto const find1 = [&] {
          uint const a(s.back()); s.pop_back();
          uint const b(find());
          uint const c(s.back()); s.pop_back();
          /* fputs("ins ", stderr), printerr(a, b, c); */
          ans.emplace_back(a, b, c);
        };
        auto const find2 = [&] {
          uint const a(find()), b(find());
          uint const c(s.back()); s.pop_back();
          /* fputs("ins ", stderr), printerr(a, b, c); */
          ans.emplace_back(a, b, c);
        };
        while (s.size() + t.size() >= 3 && !t.empty())
          (s.size() < t.size() ? find2() : find1());
      }
      printf("Case #%hu: %zu\n", x, ans.size());
      for (auto const [p, q, r] : ans) printf("%u %u %u\n", p, q, r);
      s.clear(), t.clear(), ans.clear();
    }
  }
  void main() {
    ushort t; cin >> t;
    for (ushort i(1); i <= t; ++i) test_case::main(i);
  }
}