#include <cstring>

#include <fstream>
#include <vector>
using namespace std;

const int MAX_N = 17;
const int INF = 0x3f3f3f3f;
const int MAX_C = (1 << MAX_N) + 2;

int N, t,  Nr = 1;
int Cost[MAX_N][MAX_N], A[MAX_N][2], B[MAX_C][MAX_N], Min[MAX_N], last[MAX_N][3];
vector < int > v[MAX_N];

int main()
{
    ifstream f("bibel.in");
    ofstream g("bibel.out");

    memset(Cost, INF, sizeof(Cost));
    memset(Min, INF, sizeof(Min));
    while(t != 2)
    {
        f >> t;
        if(!t)
            f >> A[N][0] >> A[N][1], ++N;
        else if(t == 1)
        {
            int Sum = INF;
            for(int i = 0; i < N; ++i)
                for(int j = 0; j < N; ++j)
                    if(i != j)
                    {
                        int t1 = A[i][0] - A[j][0], t2 = A[i][1] - A[j][1];
                        Cost[i][j] = Cost[j][i] = t1 * t1 + t2 * t2;
                        v[i].push_back(j), v[j].push_back(i);
                    }
            for(int q = 0; q < Nr; ++q)
            {
                int x = last[q][0], y = last[q][1];
                
                for(int p = 0; p < N; ++p)
                {
                    memset(B, INF, sizeof(B));
                    B[(1 << p)][p] = 0;
                    for(int i = 1; i < (1 << N); ++i)
                        for(int j = 0; j < N; ++j)
                            if(i & (1 << j))
                            {
                                for(int k = 0; k < v[j].size(); ++k)
                                    if(i & (1 << v[j][k])) 
                                        B[i][j] = min(B[i][j], B[i ^ (1 << j)][ v[j][k] ] + Cost[ v[j][k] ][j]); 
                            }   

                    int Tmp = INF;
                    for(int i = 0; i < N; ++i)
                        if(i != p)
                            Tmp = min(Tmp, B[(1 << N) - 1][i]);
                    int t1 = A[p][0] - x, t2 = A[p][1] - y;
                    int t = t1 * t1 + t2 * t2;
                    if(Tmp + last[q][2] + t < Sum)
                        Sum = Tmp + last[q][2] + t;
                    for(int i = 0; i < N; ++i)
                        if(i != p)
                            if(B[(1 << N) - 1][i] + last[q][2] + t < Min[i])
                                Min[i] = B[(1 << N) - 1][i] + last[q][2] + t;
                }
            }
            memset(Cost, INF, sizeof(Cost));
            Nr = N;
            for(int i = 0; i < Nr; ++i)
                last[i][0] = A[i][0], last[i][1] = A[i][1], last[i][2] = Min[i];
           
            for(int i = 0; i < N; ++i)
                g << Min[i] << " ";
            g << '\n';
            memset(Min, INF, sizeof(Min));
            N = 0;
            for(int i = 0; i < N; ++i)
                v[i].clear();
            
            g << Sum << '\n';
        }   
    } 
    
    f.close();
    g.close();

    return 0;
}