#include <bits/stdc++.h>

#define ll long long
#define fors(u, n, s) for(ll u=(s); u < (n); u++)
#define foru(u, n) fors(u, n, 0)
#define ir(a, b, x) (((a) <= (x)) && ((x) <= (b)))
#define vec vector
#define pb push_back

using namespace std;

int n;
#define K 21
#define N 10000
#define M 4000000

struct seg{
    int a;
    int b;

    bool operator<=(const seg rhs) const{
        return rhs.a<=a && rhs.b>=b;
    }

    bool operator>=(const seg rhs) const{
        return a<=rhs.a && rhs.b<=b;
    }

    bool operator==(const seg rhs) const{
        return ir(a, b, rhs.a) || ir(rhs.a, rhs.b, a);
    }

    bool operator!=(const seg rhs) const{
        return !(ir(a, b, rhs.a) || ir(rhs.a, rhs.b, a));
    }

    int to_int(){
        return b-a+1;
    }

    seg halfA(){
        int m=(a+b)/2;
        seg out;
        out.a=a;
        out.b=m;
        return out;
    }

    seg halfB(){
        int m=(a+b)/2;
        seg out;
        out.a=m+1;
        out.b=b;
        return out;
    }

    seg operator*(const seg rhs) const{
        seg out;
        out.a=max(a, rhs.a);
        out.b=min(b, rhs.b);
        return out;
    }

    bool valid(){
        return a<=b;
    }
};

seg make_seg(int a, int b){
    seg out;
    out.a=a;
    out.b=b;
    return out;
}

int a[N];
int b[N];

struct rect{
    seg x;
    seg y;

    bool valid(){
        return x.valid() && y.valid();
    }

    rect operator*(const rect rhs) const{
        rect out;
        out.x=x*(rhs.x);
        out.y=y*(rhs.y);
        return out;
    }

    bool operator==(const rect rhs) const{
        return x.a==rhs.x.a && x.b==rhs.x.b && y.a==rhs.y.a && y.b==rhs.y.b;
    }

    int to_int(){
        return x.to_int()*y.to_int();
    }

    pair<rect, rect> split(){
        if(x.to_int()!=1){
            pair<rect, rect> output;
            output.first.x=x.halfA();
            output.first.y=y;

            output.second.x=x.halfB();
            output.second.y=y;
            return output;
        }else{
            pair<rect, rect> output;
            output.first.x=x;
            output.first.y=y.halfA();

            output.second.x=x;
            output.second.y=y.halfB();
            return output;
        }
    }
};

rect make_rect(seg x, seg y){
    rect output;
    output.x=x;
    output.y=y;
    return output;
}

vec<rect> rectangles;

void add_edge(int A, int B, int C, int D){
    /// A C
    /// B D
        /// A i B' i C'
        {seg l = make_seg(1, A);
        seg r = make_seg(A, 2*n);

        seg b_seg;
        if(B<A) b_seg=make_seg(B+1, 2*n);
        else b_seg=make_seg(1, B-1);

        seg c_seg;
        if(C<A) c_seg=make_seg(C+1, 2*n);
        else c_seg=make_seg(1, C-1);

        //add(tree, l*b_seg*c_seg, r*b_seg*c_seg, 1);
        seg x = l*b_seg*c_seg; seg y = r*b_seg*c_seg;
        rectangles.pb(make_rect(x, y));
        }

        /// B i A' i D'
        {seg l = make_seg(1, B);
        seg r = make_seg(B, 2*n);

        seg a_seg;
        if(A<B) a_seg=make_seg(A+1, 2*n);
        else a_seg=make_seg(1, A-1);

        seg d_seg;
        if(D<B) d_seg=make_seg(D+1, 2*n);
        else d_seg=make_seg(1, D-1);

        //add(tree, l*a_seg*d_seg, r*a_seg*d_seg, 1);
        seg x = l*a_seg*d_seg; seg y = r*a_seg*d_seg;
        rectangles.pb(make_rect(x, y));

        }

        /// A i B i C' i D'
        {seg l = make_seg(1, A) * make_seg(1, B);
        seg r = make_seg(A, 2*n) * make_seg(B, 2*n);

        bool valid=true;

        seg c_seg;
        if(C<min(A, B)) c_seg=make_seg(C+1, 2*n);
        else if(C>max(A, B)) c_seg=make_seg(1, C-1);
        else valid=false;

        seg d_seg;
        if(D<min(A, B)) d_seg=make_seg(D+1, 2*n);
        else if(D>max(A, B)) d_seg=make_seg(1 , D-1);
        else valid=false;



        if(valid&&(l*c_seg*d_seg).valid()&&(r*c_seg*d_seg).valid()) {
                //add(tree, l*c_seg*d_seg, r*c_seg*d_seg, 1);
                seg x = l*c_seg*d_seg; seg y = r*c_seg*d_seg;
                rectangles.pb(make_rect(x, y));
            }
        }
}



vec<int> process(vec<rect>* rects, rect range){
    if(range.to_int()==1 || rects->size()==0){
        if(rects->size()!=0) cout << "PANIK" << endl;
        vec<int> output;
        foru(i, K) output.pb(0);
        output[0]=range.to_int();
        //cout << "range " << range.x.a << " " <<range.x.b << ", " << range.y.a << " " << range.y.b << endl;
        //foru(i, K) cout << output[i] << " "; cout << endl;
        return output;
    }

    pair<rect, rect> divide = range.split();
    int val[2]; val[0]=0; val[1]=0;
    vec<rect> to_first; vec<rect> to_second;
    for(auto i : *rects){
        if((i*divide.first).valid()){
            if((i*divide.first)==divide.first) val[0]++;
            else to_first.pb(i*divide.first);
        }
        if((i*divide.second).valid()){
            if((i*divide.second)==divide.second) val[1]++;
            else to_second.pb(i*divide.second);
        }
    }
    vec<int> vec1 = process(&to_first, divide.first);
    vec<int> vec2 = process(&to_second, divide.second);

    for(int i=K-1; i>=0; i--){
        if(i-val[0]>=0) vec1[i]=vec1[i-val[0]];
        else vec1[i]=0;
        if(i-val[1]>=0) vec2[i]=vec2[i-val[1]];
        else vec2[i]=0;
    }

    vec<int> output;
    foru(i, K) output.pb(vec1[i]+vec2[i]);

    //cout << "range " << range.x.a << " " <<range.x.b << ", " << range.y.a << " " << range.y.b << endl;
    //foru(i, K) cout << output[i] << " "; cout << endl;

    return output;
}



int main()
{
    srand(0);
    //cin >> n; int k; cin >> k;

    //foru(i, n) cin >> a[i];
    //foru(i, n) cin >> b[i];
    n=N; int k=10;

    vec<int> deck;
    foru(i, 2*n) deck.pb(i+1);
    random_shuffle(deck.begin(), deck.end());
    foru(i, n) a[i]=deck[i];
    foru(i, n) b[i]=deck[i+n];

    foru(i, n-1){ ///ADDING EDGES
        ///A C
        ///B D
        add_edge(a[i], b[i], a[i+1], b[i+1]);
        add_edge(a[i+1], b[i+1], a[i], b[i]);
    }
    add_edge(a[n-1], b[n-1], a[0], b[0]);
    add_edge(a[0], b[0], a[n-1], b[n-1]);

    /*cout << "BEGINT RECTS" << endl;
    for(auto i : rectangles){
        cout << i.x.a << " " << i.x.b << ", " << i.y.a << " " << i.y.b << endl;
    }
    cout << "END" << endl;*/

    vec<int> output = process(&rectangles, make_rect(make_seg(1, 2*n), make_seg(1, 2*n)));

    cout << output[0] + output[2] - (2*n)*(2*n) + (2*n)*(2*n+1)/2 << " ";
    fors(i, k, 1) cout << output[2*(i+1)] << " ";

    return 0;
}