LOJ 1285

#include <bits/stdc++.h>
// #include <iostream>
// #include <cstdio>
// #include <cstdlib>
// #include <algorithm>
// #include <cmath>
// #include <vector>
// #include <set>
// #include <map>
// #include <queue>
// #include <stack>
// #include <ctime>
// #include <cassert>
// #include <complex>
// #include <string>
// #include <cstring>
// #include <bitset>
using namespace std;

// #pragma GCC optimize("Ofast,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("unroll-loops")

#define ll              long long int
#define vi              vector< int >
#define vll             vector< ll >

#define sc              scanf
#define pf              printf
#define cspf(i)         pf("Case %d:\n", i)
#define spc             pf(" ")
#define line            pf("\n")

#define ff              first
#define ss              second
#define mp              make_pair
#define pb              push_back
#define ppb             pop_back
#define tp(v,j)         get<j>(v)
#define Log(b,x)        (log(x)/log(b))

#define FOR(i,x,y)      for(int i = int(x); i < int(y); i++)
#define ROF(i,x,y)      for(int i = int(x)-1; i >= int(y); i--)
#define clr(arr,x)      memset(arr, x, sizeof arr)
#define vout(v,sz)      for(int w=0;w<sz;w++){if(w) spc; cout<<v[w];}
#define all(v)          v.begin(), v.end()
#define rall(v)         v.rbegin(), v.rend()
#define unq(v)          sort(all(v)),(v).resize(unique(all(v))-v.begin())
#define fastIO          ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)

#define sc1(x)          sc("%d",&x)
#define sc2(x,y)        sc("%d %d", &x, &y)
#define sc3(x,y,z)      sc("%d %d %d", &x, &y, &z)
#define scl1(x)         sc("%lld",&x)
#define scl2(x,y)       sc("%lld %lld", &x, &y)
#define scf1(x)         sc("%lf",&x);
#define scf2(x,y)       sc("%lf %lf", &x, &y)

#define pf1(x)          pf("%d",x)
#define pf2(x,y)        pf("%d %d", x, y)
#define pfl1(x)         pf("%lld ",x)
#define pfl2(x,y)       pf("%lld %lld", x, y)

#define MOD             (int)(1e9)
#define MaxN            1000000
#define inf             0x3f3f3f3f
#define PI              acos(-1.0)  // 3.1415926535897932
#define eps             1e-6

#ifdef ERFANUL007
    #define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template < typename Arg1 >
    void __f(const char* name, Arg1&& arg1){
        cout << name << " = " << arg1 << std::endl;
    }
    template < typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names, ',');
        cout.write(names, comma - names) << " = " << arg1 <<" | ";
        __f(comma+1, args...);
    }
#else
    #define debug(...)
#endif

template <class T> inline T bigMod(T p,T e,T M){T ret=1; for(;e>0;e>>=1){ if(e&1) ret=(ret*p)%M; p=(p*p)%M;} return (T)ret;}
template <class T> inline T modInverse(T a,T M){return bigMod(a,M-2,M);}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T lcm(T a,T b) {a=abs(a);b=abs(b); return (a/gcd(a,b))*b;}

int dx[] = { 1,-1, 0, 0};                //graph moves
int dy[] = { 0, 0, 1,-1};               //graph moves

struct PT{
    ll x, y;
    int id;
    PT(){}
    PT(ll x, ll y) : x(x), y(y), id(0) {}
    PT(ll x, ll y, int id) : x(x), y(y), id(id) {}
    void scan(){ scanf("%lld %lld",&x,&y);}
    void prnt(){ printf("%lld %lld\n",x, y);}
    inline bool operator == (const PT &p) const {
        return (x == p.x && y == p.y);
    }
    inline bool operator < (const PT &p) const {
        return ((x < p.x) || (x == p.x && y < p.y));
    }
};

ll SQ(ll x){ return x*x;}
/* return the euclidean distance of two point */
ll Dis(PT a,PT b){ return SQ(a.x-b.x) + SQ(a.y-b.y);}

double absDis(PT a,PT b){ return sqrt(Dis(a,b));}

/*convert degree to radian*/
double toRadian(double x){ return (x*(PI/180.0));}
/*convert radian to degree*/
double toDegree(double x){ return (x*(180.0/PI));}

/*convert a coordinate p from cartesian to polar
r = sqrt(x*x + y*y)
theta = atan(y/x) [in radian]*/
PT toPolar(PT p){
    return PT(sqrt(SQ(p.x)+SQ(p.y)), atan(p.y/p.x));
}
/*convert a coordinate p from polar to cartesian
x = r * cos(theta) [in radian]
y = r * sin(theta) [in radian]*/
PT toCartesian(PT a){
    return PT(a.x * cos(a.y), a.x * sin(a.y));
}

/* divide line ab into m:n and return midpoint */
PT divideLine(PT a, PT b, double m, double n){
    return PT((a.x * m + b.x * n)/(m+n), (a.y * m + b.y * n)/(m+n));
}

/* convert two points to vector line */
PT vect(PT a,PT b){ return PT(a.x-b.x, a.y-b.y);}
/* two vector lines Dot product */
ll Dot(PT a,PT b){ return a.x*b.x + a.y*b.y;}
/* two vector lines Cross product */
ll Cross(PT a,PT b){ return a.x*b.y - b.x*a.y;}

/* line ab to point c
0 => if ab and c collinear
+ => clockwise
- => anticlockwise */
int orientation(PT a, PT b, PT c)
{
    ll val = (b.y-a.y)*(c.x-b.x)-(b.x-a.x)*(c.y-b.y);
    if(val == 0) return 0;
    return val > 0 ? 1 : -1;
}

/* area of Triangle abc
positive -> anticlockwise
negative -> clockwise
zero -> collinear */
ll TriArea(PT a, PT b, PT c){ return Cross(vect(b, a), vect(c, a));}

/*line ab and line cd is parallel if ab X cd = 0 */
bool ifParallel(PT a,PT b,PT c,PT d){ return Cross(vect(a,b),vect(c,d)) == 0;}

/*line ab and line cd is perpendicular if ab . cd = 0 */
bool ifPerpendicular(PT a,PT b,PT c,PT d){ return Dot(vect(a,b),vect(c,d)) == 0;}

/* segment ab and segment cd intersect or not */
bool isSegIntersect(PT a,PT b,PT c,PT d){
    if(a.x > b.x) swap(a, b);
    if(a.y > b.y) swap(a, b);
    if(orientation(a, b, c) == 0) return c.x >= a.x && c.x <= b.x && c.y >= a.y && c.y <= b.y;
    if(orientation(a, b, d) == 0) return d.x >= a.x && d.x <= b.x && d.y >= a.y && d.y <= b.y;
    return (orientation(a, b, c) != orientation(a, b, d)
        && orientation(c, d, a) != orientation(c, d, b));
}

/* init first coordinate of array to f = arr[0] */
PT _f;
/*for clockwise sorting*/
bool CC(PT &a,PT &b){ return (_f.x-a.x)*(_f.y-b.y)<(_f.x-b.x)*(_f.y-a.y);}
/*for anti-clockwise sorting*/
bool CCW(PT &a,PT &b){ return (_f.x-a.x)*(_f.y-b.y)>(_f.x-b.x)*(_f.y-a.y);}
/* init first coordinate of array to _f = lowest left
swap lowest left with 0th and sort start from 1st
compare _fab, how it turns, if collinear sort by distance */
/* for clockwise sorting */
bool ClockCmp(PT &a,PT &b){
    ll val = orientation(_f, a, b);
    if(val == 0) return Dis(_f, a) < Dis(_f, b);
    return val > 0;
}
/* for anti-clockwise sorting */
bool AClockCmp(PT &a,PT &b){
    ll val = orientation(_f, a, b);
    if(val == 0) return Dis(_f, a) < Dis(_f, b);
    return val < 0;
}
//--------------------------//

/* receive a list of points and return their concave hull */
bool possible; // mark if possible or not
vector< PT > GrahamScan(vector< PT >& v){
    int n = v.size();
    if(n < 3) return v;
    _f = v[0];
    int pivot = 0;
    for(int i=1; i<v.size(); i++){
        if(v[i].y < _f.y) _f = v[i], pivot = i;
        else if(v[i].y == _f.y && v[i].x < _f.x) _f = v[i], pivot = i;
    }
    swap(v[0], v[pivot]);
    sort(v.begin()+1, v.end(), AClockCmp);
    vector< PT > hull;
    hull.pb(v[0]); hull.pb(v[1]);
    for(int i=2; i<n; i++){
        if(orientation(hull[hull.size()-2], hull.back(), v[i])) possible = true;
        hull.pb(v[i]);
    }
    pivot = n-1;
    for(int i=n-2; i>=0; i--){
        if(orientation(hull[0], hull[pivot], hull[i])) break;
        pivot = i;
    }
    reverse(hull.begin()+pivot, hull.end());
    return hull;
}

int main()
{
    #ifdef ERFANUL007
        clock_t tStart = clock();
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif

    int t, ca=0; sc1(t);

    while(t--){
        int n; sc1(n);
        vector< PT > v(n);
        for(int i=0; i<n; i++){
            ll x, y; scl2(x, y);
            v[i] = PT(x, y, i);
        }
        possible = false;
        vector< PT > ConcaveHull = GrahamScan(v);
        cspf(++ca);
        if(!possible){
            pf("Impossible\n");
            continue;
        }
        for(int i=0; i<n; i++){
            if(i) spc;
            pf1(ConcaveHull[i].id);
        }
        line;
    }


    #ifdef ERFANUL007
        fprintf(stderr, "\n>> Runtime: %.10fs\n", (double) (clock() - tStart) / CLOCKS_PER_SEC);
    #endif

    return 0;
}