#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;

#define lp(var,start,end) for (ll var = start; var <end ; ++var)
#define rlp(var,start,end) for(ll var = start; var>=end ; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define endl "\n"
const ll N=3e5+5,inf=1e9;
ll ary[N][2],p[3][N];
ll dp[N][3];
ll n;

ll solve(ll i,ll f)
{
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	if(f==3)return 0;
	if(i==n)return -inf;
	if(dp[i][f]==-inf)
	{
		dp[i][f]=max(dp[i][f],solve(i+1,f));
		dp[i][f]=max(dp[i][f],solve(i+1,f+1)+p[f][i]);
	}
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	return dp[i][f];
}
int main()
{
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
	cin >> n;
	ll mxx=-inf,mnx=inf,mxy=-inf,mny=inf;
	lp(i,0,n)
	{
		cin >> ary[i][0] >> ary[i][1];
		mxx=max(ary[i][0],mxx);
		mxy=max(ary[i][1],mxy);
		mnx=min(ary[i][0],mnx);
		mny=min(ary[i][1],mny);
	}
	// ary[n][0]=ary 	[0][0],ary[n][1]=ary[0][1];
	ll a[2],ans=-1;
	a[0]=1,a[1]=-1;
	lp(i,0,2)
		lp(j,0,2)
			lp(k,0,2)
				lp(l,0,2)
					lp(m,0,2)
						lp(x,0,2)
						{
							ll c1 = a[i] - a[k];
							ll c2 = -a[i] + a[j];
							ll c3 = -a[j] + a[k];
							ll c4 = a[l] - a[x];
							ll c5 = -a[l] + a[m];
							ll c6 = -a[m] + a[x];
							lp(z,0,n)
							{
								p[0][z]=c1*ary[z][0]+c4*ary[z][1];
								p[1][z]=c2*ary[z][0]+c5*ary[z][1];
								p[2][z]=c3*ary[z][0]+c6*ary[z][1];
								// cout<<p[0][z]<<" "<<p[1][z]<<" "<<p[2][z]<<endl;
							}
							lp(i,0,n)
								lp(j,0,3)
									dp[i][j]=-inf;
							ans=max(ans,solve(0,0));
							// cout<<ans<<endl;
						}
	cout<<ans<<" ";
	lp(i,3,n)
	{
		cout<<2*(mxx-mnx + mxy - mny)<<" ";
	}
	cout<<endl;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;

#define lp(var,start,end) for (ll var = start; var <end ; ++var)
#define rlp(var,start,end) for(ll var = start; var>=end ; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define endl "\n"
const ll N=3e5+5,inf=1e9;
ll ary[N][2],p[3][N];
ll dp[N][3];
ll n;

ll solve(ll i,ll f)
{
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	if(f==3)return 0;
	if(i==n)return -inf;
	if(dp[i][f]==-inf)
	{
		dp[i][f]=max(dp[i][f],solve(i+1,f));
		dp[i][f]=max(dp[i][f],solve(i+1,f+1)+p[f][i]);
	}
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	return dp[i][f];
}
int main()
{
    //ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
	cin >> n;
	ll mxx=-inf,mnx=inf,mxy=-inf,mny=inf;
	lp(i,0,n)
	{
		cin >> ary[i][0] >> ary[i][1];
		mxx=max(ary[i][0],mxx);
		mxy=max(ary[i][1],mxy);
		mnx=min(ary[i][0],mnx);
		mny=min(ary[i][1],mny);
	}
	// ary[n][0]=ary 	[0][0],ary[n][1]=ary[0][1];
	ll a[2],ans=-1;
	a[0]=1,a[1]=-1;
	lp(i,0,2)
		lp(j,0,2)
			lp(k,0,2)
				lp(l,0,2)
					lp(m,0,2)
						lp(x,0,2)
						{
							ll c1 = a[i] - a[k];
							ll c2 = -a[i] + a[j];
							ll c3 = -a[j] + a[k];
							ll c4 = a[l] - a[x];
							ll c5 = -a[l] + a[m];
							ll c6 = -a[m] + a[x];
							lp(z,0,n)
							{
								p[0][z]=c1*ary[z][0]+c4*ary[z][1];
								p[1][z]=c2*ary[z][0]+c5*ary[z][1];
								p[2][z]=c3*ary[z][0]+c6*ary[z][1];
								// cout<<p[0][z]<<" "<<p[1][z]<<" "<<p[2][z]<<endl;
							}
							lp(i,0,n)
								lp(j,0,3)
									dp[i][j]=-inf;
							ans=max(ans,solve(0,0));
							// cout<<ans<<endl;
						}
	cout<<ans<<" ";
	lp(i,3,n)
	{
		cout<<2*(mxx-mnx + mxy - mny)<<" ";
	}
	cout<<endl;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef int ll;
typedef long double ld;

#define lp(var,start,end) for (ll var = start; var <end ; ++var)
#define rlp(var,start,end) for(ll var = start; var>=end ; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define endl "\n"
const ll N=3e5+5,inf=1e9;
ll ary[N][2],p[3][N];
ll dp[N][3];
ll n;

ll solve(ll i,ll f)
{
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	if(f==3)return 0;
	if(i==n)return -inf;
	if(dp[i][f]==-inf)
	{
		dp[i][f]=max(dp[i][f],solve(i+1,f));
		dp[i][f]=max(dp[i][f],solve(i+1,f+1)+p[f][i]);
	}
	// cout<<" "<<i<<" "<<f<<" "<<dp[i][f]<<endl;
	return dp[i][f];
}
int main()
{
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
	cin >> n;
	ll mxx=-inf,mnx=inf,mxy=-inf,mny=inf;
	lp(i,0,n)
	{
		cin >> ary[i][0] >> ary[i][1];
		mxx=max(ary[i][0],mxx);
		mxy=max(ary[i][1],mxy);
		mnx=min(ary[i][0],mnx);
		mny=min(ary[i][1],mny);
	}
	// ary[n][0]=ary 	[0][0],ary[n][1]=ary[0][1];
	ll a[2],ans=-1;
	a[0]=1,a[1]=-1;
	lp(i,0,2)
		lp(j,0,2)
			lp(k,0,2)
				lp(l,0,2)
					lp(m,0,2)
						lp(x,0,2)
						{
							ll c1 = a[i] - a[k];
							ll c2 = -a[i] + a[j];
							ll c3 = -a[j] + a[k];
							ll c4 = a[l] - a[x];
							ll c5 = -a[l] + a[m];
							ll c6 = -a[m] + a[x];
							lp(z,0,n)
							{
								p[0][z]=c1*ary[z][0]+c4*ary[z][1];
								p[1][z]=c2*ary[z][0]+c5*ary[z][1];
								p[2][z]=c3*ary[z][0]+c6*ary[z][1];
								// cout<<p[0][z]<<" "<<p[1][z]<<" "<<p[2][z]<<endl;
							}
							lp(i,0,n)
								lp(j,0,3)
									dp[i][j]=-inf;
							ans=max(ans,solve(0,0));
							// cout<<ans<<endl;
						}
	cout<<ans<<" ";
	lp(i,3,n)
	{
		cout<<2*(mxx-mnx + mxy - mny)<<" ";
	}
	cout<<endl;
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define X first
#define Y second
const int maxn = 3e5 + 5;
const int inf = 1e9;
int n;
pii p[maxn];
int main() {
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d%d",&p[i].X,&p[i].Y);
	int mnx = inf, mny = inf, mxx = -inf, mxy = -inf;
	for(int i=1;i<=n;i++) {
        mxx = max(mxx, p[i].X);
        mxy = max(mxy, p[i].Y);
        mnx = min(mnx, p[i].X);
        mny = min(mny, p[i].Y);
	}
	//case 3
	int ans3 = 0;
	//mx mx
	for(int i=1;i<=n;i++) {
        ans3 = max(ans3, p[i].X - mnx + p[i].Y - mny);
	}
	//mx mn
	for(int i=1;i<=n;i++) {
        ans3 = max(ans3, p[i].X - mnx + mxy - p[i].Y);
	}
	//mn mx
	for(int i=1;i<=n;i++) {
        ans3 = max(ans3, mxx - p[i].X + p[i].Y - mny);
	}
	//mn mn
	for(int i=1;i<=n;i++) {
        ans3 = max(ans3, mxx - p[i].X + mxy - p[i].Y);
	}
	//case 4+
	int ans4 = mxx - mnx + mxy - mny;
	printf("%d ",ans3*2);
	for(int i=4;i<=n;i++) printf("%d ",ans4*2);
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1e3 + 5;
struct node {
	int x,y;
};
int n;
node p[maxn];
int l[maxn], r[maxn];
ll val[maxn];
set<pair<ll,int>> s;
ll cal(int x, int y) {
	return abs(p[x].x-p[y].x) + abs(p[x].y-p[y].y);
}
void build(int i) {
	int a = l[i], b = i, c = r[i];
	val[i] = cal(a,b) + cal(b,c) - cal(a,c);
	s.insert({val[i],i});
}
int main() {
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d%d",&p[i].x,&p[i].y);
	ll ans = 0;
	for(int i=0;i<n;i++) {
		l[i] = (i-1+n)%n;
		r[i] = (i+1+n)%n;
		ans += cal(i,r[i]);
		printf("%lld\n",cal(i,r[i]));
	}
	for(int i=0;i<n;i++) build(i);
	vector<ll> vec;
	vec.push_back(ans);
	for(int i=n-1;i>=3;i--) {
		auto it = s.begin();
		ans -= it->first;
		int x = it->second;
		int L = l[x], R = r[x];
		l[R] = L; r[L] = R;
		s.erase(s.find({val[L],L}));
		s.erase(s.find({val[R],R}));
		build(L); build(R);
		vec.push_back(ans);
	}
	reverse(vec.begin(),vec.end());
	for(auto t : vec) printf("%lld ",t);
}


#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 3e5 + 5;
struct node {
	int x,y;
};
int n;
node p[maxn];
int l[maxn], r[maxn];
ll val[maxn];
set<pair<ll,int>> s;
ll cal(int x, int y) {
	return abs(p[x].x-p[y].x) + abs(p[x].y-p[y].y);
}
void build(int i) {
	int a = l[i], b = i, c = r[i];
	val[i] = cal(a,b) + cal(b,c) - cal(a,c);
	s.insert({val[i],i});
}
int main() {
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d%d",&p[i].x,&p[i].y);
	ll ans = 0;
	for(int i=0;i<n;i++) {
		l[i] = (i-1+n)%n;
		r[i] = (i+1+n)%n;
		ans += cal(i,r[i]);
	}
	for(int i=0;i<n;i++) build(i);
	vector<ll> vec;
	vec.push_back(ans);
	for(int i=n-1;i>=3;i--) {
		auto it = s.begin();
		ans -= it->first;
		int x = it->second;
		int L = l[x], R = r[x];
		l[R] = L; r[L] = R;
		s.erase(s.find({val[L],L}));
		s.erase(s.find({val[R],R}));
		build(L); build(R);
		vec.push_back(ans);
	}
	reverse(vec.begin(),vec.end());
	for(auto t : vec) printf("%lld ",t);
}


#include<bits/stdc++.h>

using namespace std;

#define pb push_back
#define fi first
#define se second
typedef pair<int, int> ii;

const int N = 3e5 + 5;
int n, x[N], y[N], ans[N], link[N][2], sum;
set<ii> sett;

int path (int i, int j) { return abs(x[i] - x[j]) + abs(y[i] - y[j]); }

int main () {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
        link[i][0] = (i - 1 + n) % n;
        link[i][1] = (i + 1) % n;
    }

    for (int i = 0; i < n; ++i) sett.insert(ii(path(i, link[i][0]) + path(i, link[i][1]) - path(link[i][0], link[i][1]), i) );

    for (int i = 0; i < n; ++i) sum += path(i, (i + 1) % n);

    for (int i = n; i > 2; --i) {
        ans[i] = sum;
        if (i == 3) continue ;
        ii tmp = *sett.begin(); sett.erase(sett.begin() );
        sum -= tmp.fi;
        int u = tmp.se;
        int v = link[u][0], w = link[u][1];
        sett.erase(ii(path(v, link[v][0]) + path(v, link[v][1]) - path(link[v][0], link[v][1]), v) );
        sett.erase(ii(path(w, link[w][0]) + path(w, link[w][1]) - path(link[w][0], link[w][1]), w) );
        link[v][1] = w;
        link[w][0] = v;
        sett.insert(ii(path(v, link[v][0]) + path(v, link[v][1]) - path(link[v][0], link[v][1]), v) );
        sett.insert(ii(path(w, link[w][0]) + path(w, link[w][1]) - path(link[w][0], link[w][1]), w) );
    }

    for (int i = 3; i <= n; ++i) cout << ans[i] << '\n';

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

#define pb push_back
#define fi first
#define se second
typedef pair<int, int> ii;

const int N = 3e5 + 5;
int n, x[N], y[N], sum, ans, maxX = -1e9, minX = 1e9, maxY = -1e9, minY = 1e9;
vector<ii> vec;

int path (int i, int j) { return abs(x[i] - x[j]) + abs(y[i] - y[j]); }

int main () {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
        maxX = max(maxX, x[i]);
        minX = min(minX, x[i]);
        maxY = max(maxY, y[i]);
        minY = min(minY, y[i]);
    }

    for (int i = 0; i < n; ++i) sum += path(i, (i + 1) % n);

    for (int i = 0; i < n; ++i) {
        ans = max(ans, abs(x[i] - maxX) + abs(y[i] - maxY) );
        ans = max(ans, abs(x[i] - minX) + abs(y[i] - maxY) );
        ans = max(ans, abs(x[i] - maxX) + abs(y[i] - minY) );
        ans = max(ans, abs(x[i] - minX) + abs(y[i] - minY) );
    }

    cout << ans * 2 << ' ';
    for (int i = 4; i <= n; ++i) cout << sum << ' ';

    return 0;
}
/*
8
0 3
2 2
3 0
2 -2
0 -3
-2 -2
-3 0
-2 2
*/


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

int peri(vector<point>& a){
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(s.size() >= 2 && mid(s[s.size()-2].x, cur.x, s.back().x) && mid(s[s.size()-2].y, cur.y, s.back().y) ){ // bad news for second last one
			//cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	if(s.size() >= 2 && mid(s[s.size()-1].x, s[1].x, s.front().x) && mid(s[s.size()-1].y, s[1].y, s.front().y)){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			auto news = s;
			news.erase(news.begin() + i);
			best3 = max(best3, peri(news));
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

int peri(vector<point>& a){
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(mid(s[s.size()-2].x, cur.x, s.back().x) && mid(s[s.size()-2].y, cur.y, s.back().y) ){ // bad news for second last one
			cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	if(mid(s[s.size()-1].x, s[1].x, s.front().x) && mid(s[s.size()-1].y, s[1].y, s.front().y)){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			auto news = s;
			news.erase(news.begin() + i);
			best3 = max(best3, peri(news));
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

bool mid(point a, point b, point c){
	return mid(a.x, b.x, c.x) && mid(a.y, b.y, c.y);
}

int peri(vector<point>& a){
	assert(a.size() > 0);
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(s.size() >= 2 && mid(s[s.size()-2], cur, s.back())){ // bad news for second last one
			//cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	while(s.size() >= 3 && mid(s[0], s[s.size()-2], s[s.size()-1])){
		s.pop_back();
	}
	if(s.size() >= 2 && mid(s[s.size()-1], s[1], s.front())){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			vector<pair<int, int> >  news = s;
			news.erase(news.begin() + i);
			best3 = max(best3, peri(news));
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

bool mid(point a, point b, point c){
	return mid(a.x, b.x, c.x) && mid(a.y, b.y, c.y);
}

int peri(vector<point> a){
	assert(a.size() > 0);
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(s.size() >= 2 && mid(s[s.size()-2], cur, s.back())){ // bad news for second last one
			//cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	while(s.size() >= 3 && mid(s[0], s[s.size()-2], s[s.size()-1])){
		s.pop_back();
	}
	if(s.size() >= 2 && mid(s[s.size()-1], s[1], s.front())){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			for(int j = i+1; j < s.size(); j++){
				for(int k = 0; k < n; k++){
					best3 = max(best3, peri({s[i], s[j], p[k]}));
				}
			}
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

bool mid(point a, point b, point c){
	return mid(a.x, b.x, c.x) && mid(a.y, b.y, c.y);
}

int peri(vector<point>& a){
	assert(a.size() > 0);
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(s.size() >= 2 && mid(s[s.size()-2], cur, s.back())){ // bad news for second last one
			//cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	while(s.size() >= 3 && mid(s[0], s[s.size()-2], s[s.size()-1])){
		s.pop_back();
	}
	if(s.size() >= 2 && mid(s[s.size()-1], s[1], s.front())){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			auto news = s;
			news.erase(news.begin() + i);
			best3 = max(best3, peri(news));
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include<bits/stdc++.h>

using namespace std;

typedef pair<int, int> point;
#define x first
#define y second

bool mid(int a, int b, int m){
	if(b < a) swap(a, b);
	if(a <= m && m <= b) return true;
	else return false;
}

int peri(vector<point>& a){
	int ans = 0;
	for(int i = 0; i < a.size(); i++){
		ans += abs(a[i].x - a[(i+1)%a.size()].x) + abs(a[i].y - a[(i+1)%a.size()].y);
	}
	return ans;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin>>n;
	vector<point> p(n);
	for(int i = 0; i < n; i++){
		cin>>p[i].x>>p[i].y;
	}
	//sort(p.begin(), p.end());
	vector<point> s = {p[0], p[1]};
	for(int i = 2; i < n; i++){
		point cur = p[i];
		//check if point s.back() is usefull
		while(mid(s[s.size()-2].x, cur.x, s.back().x) && mid(s[s.size()-2].y, cur.y, s.back().y) ){ // bad news for second last one
			//cout<<"POPPED OUT "<<i<<endl;
			s.pop_back();
		}
		s.push_back(cur);
	}
	//check with last one as well; maybe not
	if(mid(s[s.size()-1].x, s[1].x, s.front().x) && mid(s[s.size()-1].y, s[1].y, s.front().y)){ // bad news for second last one
		//cout<<" POPOP"<<endl;
		s.erase(s.begin());
	}
	assert(s.size() <= 4);
	int best3 = 0;
	if(s.size() <= 3){
		best3 = peri(s);
	}else{
		for(int i = 0; i < s.size(); i++){
			auto news = s;
			news.erase(news.begin() + i);
			best3 = max(best3, peri(news));
		}
	}
	int best4 = peri(s);
	cout<<best3<<" ";
	for(int i = 4; i <= n; i++){
		cout<<best4<<" ";
	}
	cout<<endl;
}


#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<int, int> point;

int triangle_perimeter(const point &a,
                       const point &b,
                       const point &c) {
    int min_x = min(a.first, min(b.first, c.first));
    int max_x = max(a.first, max(b.first, c.first));
    int min_y = min(a.second, min(b.second, c.second));
    int max_y = max(a.second, max(b.second, c.second));
    return 2 * (max_x - min_x) + 2 * (max_y - min_y);
}

int max_triangle_perimeter(const vector<point> &points,
                           const point &a,
                           const point &b,
                           const point &c,
                           const point &d) {
    int ans = -1;
    for (auto p : points) {
        ans = max(ans, triangle_perimeter(p, a, b));
        ans = max(ans, triangle_perimeter(p, a, c));
        ans = max(ans, triangle_perimeter(p, a, d));
        ans = max(ans, triangle_perimeter(p, b, c));
        ans = max(ans, triangle_perimeter(p, b, d));
        ans = max(ans, triangle_perimeter(p, c, d));
    }
    return ans;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<pair<int, int>> a(n);
    for (auto &p : a) {
        cin >> p.first >> p.second;
    }
    auto it_min_x = min_element(begin(a), end(a));
    auto it_max_x = max_element(begin(a), end(a));
    auto comp_y = [](const auto &a, const auto &b) {
                      return a.second < b.second;
                  };
    auto it_min_y = min_element(begin(a), end(a), comp_y);
    auto it_max_y = max_element(begin(a), end(a), comp_y);
    int ans3 = max_triangle_perimeter(a,
                                      *it_min_x,
                                      *it_max_x,
                                      *it_min_y,
                                      *it_max_y);
    int ans4 = 2 * (it_max_x->first - it_min_x->first) +
               2 * (it_max_y->second - it_min_y->second);
    cout << ans3;
    for (int i = 4; i <= n; ++i) {
        cout << ' ' << ans4;
    }
    cout << endl;
    return 0;
}


#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<int, int> point;

int triangle_perimeter(const point &a,
                       const point &b,
                       const point &c) {
    int min_x = min(a.first, min(b.first, c.first));
    int max_x = max(a.first, max(b.first, c.first));
    int min_y = min(a.second, min(b.second, c.second));
    int max_y = max(a.second, max(b.second, c.second));
    return 2 * (max_x - min_x) + 2 * (max_y - min_y);
}

int max_triangle_perimeter(const point &a,
                           const point &b,
                           const point &c,
                           const point &d) {
    return max(triangle_perimeter(a, b, c),
           max(triangle_perimeter(a, b, d),
           max(triangle_perimeter(a, c, d),
               triangle_perimeter(b, c, d))));
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<pair<int, int>> a(n);
    for (auto &p : a) {
        cin >> p.first >> p.second;
    }
    auto it_min_x = min_element(begin(a), end(a));
    auto it_max_x = max_element(begin(a), end(a));
    auto comp_y = [](const auto &a, const auto &b) {
                      return a.second < b.second;
                  };
    auto it_min_y = min_element(begin(a), end(a), comp_y);
    auto it_max_y = max_element(begin(a), end(a), comp_y);
    int ans3 = max_triangle_perimeter(*it_min_x, *it_max_x,
                                      *it_min_y, *it_max_y);
    int ans4 = 2 * (it_max_x->first - it_min_x->first) +
               2 * (it_max_y->second - it_min_y->second);
    cout << ans3;
    for (int i = 4; i <= n; ++i) {
        cout << ' ' << ans4;
    }
    cout << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define fi first
#define se second

int n, x[300007], y[300007];
int maxx = -1e9, maxy = -1e9, minx = 1e9, miny = 1e9;
int ans = 0, res = 0;

int cal(int a, int b){
	return abs(x[a] - x[b]) + abs(y[a] - y[b]);
}

int main(){
	ios_base::sync_with_stdio(0);
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> x[i] >> y[i];
	}
	for(int i = 0; i < n; i++){
		ans += cal(i, (i + 1) % n);
		minx = min(minx, x[i]), maxx = max(maxx, x[i]);
		miny = min(miny, y[i]), maxy = max(maxy, y[i]);
	}
	for(int i = 0; i < n; i++){
		res = max(res, maxx + maxy - x[i] - y[i]);
		res = max(res, maxx + y[i] - x[i] - miny);
		res = max(res, x[i] + maxy - minx - y[i]);
		res = max(res, x[i] + y[i] - minx - miny);
	}
	res *= 2;
	for(int i = 3; i <= n; i++){
		if(i == 4) cout << res;
		else cout << ans;
		cout << " ";
	}
}


#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define fi first
#define se second

int n, x[300007], y[300007];
int maxx = -1e9, maxy = -1e9, minx = 1e9, miny = 1e9;
int ans = 0, res = 0;

int cal(int a, int b){
	return abs(x[a] - x[b]) + abs(y[a] - y[b]);
}

int main(){
	ios_base::sync_with_stdio(0);
	cin >> n;
	for(int i = 0; i < n; i++){
		cin >> x[i] >> y[i];
	}
	for(int i = 0; i < n; i++){
		ans += cal(i, (i + 1) % n);
		minx = min(minx, x[i]), maxx = max(maxx, x[i]);
		miny = min(miny, y[i]), maxy = max(maxy, y[i]);
	}
	for(int i = 0; i < n; i++){
		res = max(res, maxx + maxy - x[i] - y[i]);
		res = max(res, maxx + y[i] - x[i] - miny);
		res = max(res, x[i] + maxy - minx - y[i]);
		res = max(res, x[i] + y[i] - minx - miny);
	}
	res *= 2;
	for(int i = 3; i <= n; i++){
		if(i == 3) cout << res;
		else cout << ans;
		cout << " ";
	}
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=1e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mn,mx;
int All;

int rk1[maxn],rk2[maxn],t1,t2;

inline void doing()
{
	mn=1e9; mx=-1e9;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mn,px[i]),chkmax(mx,px[i]);
	REP(i,1,n-1)All+=abs(px[i]-px[i+1])+abs(py[i]-py[i+1]);
	All+=abs(px[n]-px[1])+abs(py[1]-py[n]);

	REP(i,1,n)if(px[i]==mn)rk1[++t1]=i;
	REP(i,1,n)if(px[i]==mx)rk2[++t2]=i;

	int ans=0;

	REP(i,1,t1)REP(j,1,t2)
	{
		int A=rk1[i],B=rk2[j];
		REP(k,1,n)if(k!=A && k!=B)
		{
			chkmax(ans,abs(px[A]-px[B])+abs(px[A]-px[k])+abs(px[k]-px[B]) +abs(py[A]-py[B])+abs(py[A]-py[k])+abs(py[k]-py[B]));
		}
	}
	printf("%d ",ans);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("C.in","r",stdin);
	freopen("C.out","w",stdout);
#endif
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mn,mx,mxy,mny;
int All;

int rk1[maxn],t1;

inline void doing()
{
	mn=1e9; mx=-1e9; mxy=-inf; mny=inf;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mn,px[i]),chkmax(mx,px[i]),chkmin(mny,py[i]),chkmax(mxy,px[i]);
	REP(i,1,n-1)All+=abs(px[i]-px[i+1])+abs(py[i]-py[i+1]);
	All+=abs(px[n]-px[1])+abs(py[1]-py[n]);

	REP(i,1,n)if(px[i]==mn || px[i]==mx || py[i]==mny ||py[i]==mxy)rk1[++t1]=i;

	int ans=0;

	REP(i,1,t1-2)REP(j,i+1,t1-1)
	{
		int A=rk1[i],B=rk1[j];
		REP(c,i+2,t1)
		{
			int k=rk1[c];
			chkmax(ans,abs(px[A]-px[B])+abs(px[A]-px[k])+abs(px[k]-px[B]) +abs(py[A]-py[B])+abs(py[A]-py[k])+abs(py[k]-py[B]));
		}
	}
	printf("%d ",ans);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("C.in","r",stdin);
	freopen("C.out","w",stdout);
#endif
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mn,mx;
int All;

int rk1[maxn],rk2[maxn],t1,t2;

inline void doing()
{
	mn=1e9; mx=-1e9;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mn,px[i]),chkmax(mx,px[i]);
	REP(i,1,n-1)All+=abs(px[i]-px[i+1])+abs(py[i]-py[i+1]);
	All+=abs(px[n]-px[1])+abs(py[1]-py[n]);

	REP(i,1,n)if(px[i]==mn)rk1[++t1]=i;
	REP(i,1,n)if(px[i]==mx)rk2[++t2]=i;

	int ans=0;

	REP(i,1,t1)REP(j,1,t2)
	{
		int A=rk1[i],B=rk2[j];
		REP(k,1,n)if(k!=A && k!=B)
		{
			chkmax(ans,abs(px[A]-px[B])+abs(px[A]-px[k])+abs(px[k]-px[B]) +abs(py[A]-py[B])+abs(py[A]-py[k])+abs(py[k]-py[B]));
		}
	}
	printf("%d ",ans);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("C.in","r",stdin);
	freopen("C.out","w",stdout);
#endif
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mn,mx,mxy,mny;
int All;

int rk1[maxn],t1;

inline void doing()
{
	mn=1e9; mx=-1e9; mxy=-inf; mny=inf;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mn,px[i]),chkmax(mx,px[i]),chkmin(mny,py[i]),chkmax(mxy,px[i]);
	REP(i,1,n-1)All+=abs(px[i]-px[i+1])+abs(py[i]-py[i+1]);
	All+=abs(px[n]-px[1])+abs(py[1]-py[n]);

	REP(i,1,n)if(px[i]==mn || px[i]==mx || py[i]==mny ||py[i]==mxy)rk1[++t1]=i;

	int ans=0;

	REP(i,1,t1-2)REP(j,i+1,t1-1)
	{
		int A=rk1[i],B=rk1[j];
		REP(c,j+2,t1)
		{
			int k=rk1[c];
			chkmax(ans,abs(px[A]-px[B])+abs(px[A]-px[k])+abs(px[k]-px[B]) +abs(py[A]-py[B])+abs(py[A]-py[k])+abs(py[k]-py[B]));
		}
	}
	printf("%d ",ans);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("C.in","r",stdin);
	freopen("C.out","w",stdout);
#endif
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mnx,mxx,mxy,mny;
int All;

inline void doing()
{
	mnx=1e9; mxx=-1e9; mxy=-inf; mny=inf;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mnx,px[i]),chkmax(mxx,px[i]),chkmin(mny,py[i]),chkmax(mxy,py[i]);
	All=2*(mxy-mny+mxx-mnx);

	int ans=0;
	REP(i,1,n)
	{
		int A=max(px[i]-mnx,mxx-px[i]),B=max(py[i]-mny,mxy-py[i]);
		chkmax(ans,A+B);
	}
	printf("%d ",ans<<1);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mnx,mxx,mxy,mny;
int All;

inline void doing()
{
	mnx=1e9; mxx=-1e9; mxy=-inf; mny=inf;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mnx,px[i]),chkmax(mxx,px[i]),chkmin(mny,py[i]),chkmax(mxy,px[i]);
	All=2*(mxy-mny+mxx-mnx);

	int ans=0;
	REP(i,1,n)
	{
		int A=max(px[i]-mnx,mxx-px[i]),B=max(py[i]-mny,mxy-py[i]);
		chkmax(ans,A+B);
	}
	printf("%d ",ans<<1);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
	doing();
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=(a),_end_=(b);i<=_end_;i++)
#define DREP(i,a,b) for(int i=(a),_end_=(b);i>=_end_;i--)
#define EREP(i,a) for(int i=start[(a)];i;i=e[i].next)
template<class T>inline void chkmax(T &a,T b){ if(a<b)a=b;}
template<class T>inline void chkmin(T &a,T b){ if(a>b)a=b;}
inline int read()
{
	int sum=0,p=1;char ch=getchar();
	while(!(('0'<=ch && ch<='9') || ch=='-'))ch=getchar();
	if(ch=='-')p=-1,ch=getchar();
	while('0'<=ch && ch<='9')sum=sum*10+ch-48,ch=getchar();
	return sum*p;
}

const int maxn=3e5+20;
const int inf=0x3f3f3f3f;

int n,px[maxn],py[maxn],mn,mx,mxy,mny;
int All;

int rk1[maxn],t1;

inline void doing()
{
	mn=1e9; mx=-1e9; mxy=-inf; mny=inf;
	n=read();
	REP(i,1,n)px[i]=read(),py[i]=read(),chkmin(mn,px[i]),chkmax(mx,px[i]),chkmin(mny,py[i]),chkmax(mxy,px[i]);
	REP(i,1,n-1)All+=abs(px[i]-px[i+1])+abs(py[i]-py[i+1]);
	All+=abs(px[n]-px[1])+abs(py[1]-py[n]);

	REP(i,1,n)if(px[i]==mn || px[i]==mx || py[i]==mny ||py[i]==mxy)rk1[++t1]=i;

	int ans=0;

	REP(i,1,t1-2)REP(j,i+1,t1-1)
	{
		int A=rk1[i],B=rk1[j];
		REP(c,j+1,t1)
		{
			int k=rk1[c];
			chkmax(ans,abs(px[A]-px[B])+abs(px[A]-px[k])+abs(px[k]-px[B]) +abs(py[A]-py[B])+abs(py[A]-py[k])+abs(py[k]-py[B]));
		}
	}
	printf("%d ",ans);
	REP(i,4,n)printf("%d ",All);
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("C.in","r",stdin);
	freopen("C.out","w",stdout);
#endif
	doing();
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100001;
pair<ll, ll> ps[N];

ll calc(int i, int j, int k){
  return
  max(max(ps[i].first, ps[k].first), ps[j].first)
  - min(min(ps[i].first, ps[k].first), ps[j].first)
  + max(max(ps[i].second, ps[k].second), ps[j].second)
  - min(min(ps[i].second, ps[k].second), ps[j].second);
}
int main() {
//  freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);

  int n;
  cin >> n;
  for(int i = 0;i < n;i++){
    scanf("%I64d %I64d", &ps[i].first, &ps[i].second);
  }
  ll mxx = -1e9, mxy = -1e9, mnx = 1e9, mny = 1e9;
  ll mn[4] = {0};
  for(int i = 0;i < n;i++){
    if(ps[i].first < mnx){
      mn[0] = i;
    }
    if(ps[i].first > mxx){
      mn[1] = i;
    }
    if(ps[i].second < mny){
      mn[2] = i;
    }
    if(ps[i].second > mxy){
      mn[3] = i;
    }

    mxx = max(mxx, ps[i].first);
    mxy = max(mxy, ps[i].second);
    mnx = min(mnx, ps[i].first);
    mny = min(mny, ps[i].second);
  }
  ll res = 0;
//  for(int i = 0;i < 4;i++){
//    cout << mn[i] << endl;
//  }
  for(int i = 0;i < 4;i++){
    for(int j = i + 1;j < 4;j++){
      for(int k = 0;k < n;k++){
        if(k == i || k == j)continue;
        res = max(res, calc(mn[i], mn[j], k));
      }
    }
  }
  cout << 2 * res << ' ';
  for(int i = 4;i <= n;i++){
    printf("%I64d ", 2 * (mxx - mnx + mxy - mny));
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 300001;
pair<ll, ll> ps[N];

ll calc(int i, int j, int k){
  return
  max(max(ps[i].first, ps[k].first), ps[j].first)
  - min(min(ps[i].first, ps[k].first), ps[j].first)
  + max(max(ps[i].second, ps[k].second), ps[j].second)
  - min(min(ps[i].second, ps[k].second), ps[j].second);
}
int main() {
//  freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);

  int n;
  cin >> n;
  for(int i = 0;i < n;i++){
    scanf("%I64d %I64d", &ps[i].first, &ps[i].second);
  }
  ll mxx = -1e9, mxy = -1e9, mnx = 1e9, mny = 1e9;
  ll mn[4] = {0};
  for(int i = 0;i < n;i++){
    if(ps[i].first < mnx){
      mn[0] = i;
    }
    if(ps[i].first > mxx){
      mn[1] = i;
    }
    if(ps[i].second < mny){
      mn[2] = i;
    }
    if(ps[i].second > mxy){
      mn[3] = i;
    }

    mxx = max(mxx, ps[i].first);
    mxy = max(mxy, ps[i].second);
    mnx = min(mnx, ps[i].first);
    mny = min(mny, ps[i].second);
  }
  ll res = 0;
//  for(int i = 0;i < 4;i++){
//    cout << mn[i] << endl;
//  }
  for(int i = 0;i < 4;i++){
    for(int j = i + 1;j < 4;j++){
      for(int k = 0;k < n;k++){
        if(k == i || k == j)continue;
        res = max(res, calc(mn[i], mn[j], k));
      }
    }
  }
  cout << 2 * res << ' ';
  for(int i = 4;i <= n;i++){
    printf("%I64d ", 2 * (mxx - mnx + mxy - mny));
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}

typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > vll;
typedef vector< pii > vpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;

const ll MOD = 1e9 + 7;

ll lgput(ll a, ll b, ll mod) {
    ll ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return ret;
}

inline ll inv(ll x, ll MOD) {
    return lgput(x, MOD - 2, MOD);
}

const ld PI = acos(-1);
const ld eps = 1e-6;

const int MAXN = 3e5 + 10;
struct str{
    int l, mid, r;
    ll pierdere;
};

int nxt[MAXN];
int prv[MAXN];

class cmp{
public:
    const bool operator() (const str &a, const str &b) {
        if(a.pierdere == b.pierdere) return a.mid < b.mid;
        return a.pierdere > b.pierdere;
    }
};
priority_queue< str, vector< str>, cmp > pq;
pair< ll, ll > v[MAXN];
ll dist(int i, int j) {
    return abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
}

void add(int i) {
    str cur;
    cur.l = prv[i];
    cur.r = nxt[i];
    cur.mid = i;
    cur.pierdere = dist(prv[i], i) + dist(i, nxt[i]) - dist(prv[i], nxt[i]);
    pq.push(cur);
}
int main() {
    #ifndef ONLINE_JUDGE
        freopen("input", "r", stdin);
    #endif

    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.precision(12);
    cout.fixed;

    int n;
    cin >> n;

    ll now = 0;
    ll cur = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        nxt[i] = i + 1;
        prv[i] = i - 1;
        if(i != 1)
            now += dist(i, i-1);
    }

    now += dist(n, 1);
    prv[1] = n;
    nxt[n] = 1;

    for(int i = 1; i <= n; ++i) {
        add(i);
    }

    vector< ll > ans(n + 5);
    for(int i = n; i > 3; --i) {

        while(prv[pq.top().mid] != pq.top().l || nxt[pq.top().mid] != pq.top().r) pq.pop();
        ll x, c;
        x = pq.top().mid;
        c = pq.top().pierdere;
        pq.pop();

        ans[i] = now;
        now -= c;
        nxt[prv[x]] = nxt[x];
        prv[nxt[x]] = prv[x];

        add(prv[x]);
        add(nxt[x]);
     }

     int valid = 0;
     while(pq.size()) {
        while(pq.size() != 0 && (prv[pq.top().mid] != pq.top().l || nxt[pq.top().mid] != pq.top().r)){ pq.pop();}
        if(pq.size()) {
            valid ++;
            pq.pop();
        }
     }
     assert(valid == 3);
     ans[3] = now;
     for(int i = 3; i <= n; ++i) cout << ans[i] << ' ';
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}

typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > vll;
typedef vector< pii > vpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;

const ll MOD = 1e9 + 7;

ll lgput(ll a, ll b, ll mod) {
    ll ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return ret;
}

inline ll inv(ll x, ll MOD) {
    return lgput(x, MOD - 2, MOD);
}

const ld PI = acos(-1);
const ld eps = 1e-6;

const int MAXN = 3e5 + 10;
struct str{
    int l, mid, r;
    ll pierdere;
    bool operator <(str &other){
        return pierdere < other.pierdere;
    }
};

bool deleted[MAXN];
int nxt[MAXN];
int prv[MAXN];

int n;

class cmp{
public:
    const bool operator() (const str &a, const str &b) {
        return a.pierdere > b.pierdere;
    }
};
priority_queue< str, vector< str>, cmp > pq;
pair< int, int > v[MAXN];
ll dist(int i, int j) {
    return abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
}

void add(int i) {
    str cur;
    cur.l = prv[i];
    cur.r = nxt[i];
    cur.mid = i;
    cur.pierdere = dist(prv[i], i) + dist(i, nxt[i]) - dist(prv[i], nxt[i]);
    pq.push(cur);
}
int main() {
    #ifndef ONLINE_JUDGE
        freopen("input", "r", stdin);
    #endif

    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.precision(12);
    cout.fixed;

    int n;
    cin >> n;

    ll now = 0;
    ll cur = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        nxt[i] = i + 1;
        prv[i] = i - 1;
        if(i != 1)
            now += dist(i, i-1);
    }

    now += dist(n, 1);
    prv[1] = n;
    nxt[n] = 1;

    for(int i = 1; i <= n; ++i) {
        add(i);
    }

    vector< ll > ans(n + 1);
    for(int i = n; i > 2; --i) {
        while(deleted[pq.top().mid] || deleted[pq.top().l] || deleted[pq.top().r]) pq.pop();
        ll x, c;
        x = pq.top().mid;
        c = pq.top().pierdere;
        pq.pop();

        ans[i] = now;
        now -= c;
        deleted[x] = true;
        nxt[prv[i]] = nxt[i];
        prv[nxt[i]] = prv[i];

        add(prv[i]);
        add(nxt[i]);
     }

     for(int i = 3; i <= n; ++i) cout << ans[i] << ' ';
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

const int MAXN = 3e5 + 10;
pair< int, int > v[MAXN];

pair< int, int > minx, maxx, miny, maxy;

int n;
int dist(pair< int, int > a, pair< int, int > b) {
    return abs(a.first - b.first) + abs(a.second - b.second);
}

int check(pair< int, int > p1, pair< int, int > p2) {
    int ans = 0;
    for(int i = 1; i <= n; ++i) {
        ans = max(ans, dist(p1, v[i]) + dist(p2, v[i]) + dist(p1, p2));
    }

    return ans;
}
int main() {

    cin >> n;

    minx.first = 1e9;
    maxx.first = -1e9;
    miny.second = 1e9;
    maxy.second = -1e9;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        if(v[i].first < minx.first) {
            minx = v[i];
        }
        if(v[i].first > maxx.first) {
            maxx = v[i];
        }
        if(v[i].second < miny.second) {
            miny = v[i];
        }
        if(v[i].second > maxy.second) {
            maxy = v[i];
        }
    }

    cout << max(max(max(check(minx, maxx), check(minx, miny)), max(check(maxx, maxy), check(miny, maxy))), max(check(minx, maxy), check(maxx, miny))) << ' ';

    for(int i = 4; i <= n; ++i) {
        cout << 2*(maxx.first - minx.first + maxy.second - miny.second) << ' ';
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}

typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > vll;
typedef vector< pii > vpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;

const ll MOD = 1e9 + 7;

ll lgput(ll a, ll b, ll mod) {
    ll ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return ret;
}

inline ll inv(ll x, ll MOD) {
    return lgput(x, MOD - 2, MOD);
}

const ld PI = acos(-1);
const ld eps = 1e-6;

const int MAXN = 3e5 + 10;
struct str{
    int l, mid, r;
    ll pierdere;
};

bool deleted[MAXN];
int nxt[MAXN];
int prv[MAXN];

int n;

class cmp{
public:
    const bool operator() (const str &a, const str &b) {
        return a.pierdere > b.pierdere;
    }
};
priority_queue< str, vector< str>, cmp > pq;
pair< int, int > v[MAXN];
ll dist(int i, int j) {
    return abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
}

void add(int i) {
    str cur;
    cur.l = prv[i];
    cur.r = nxt[i];
    cur.mid = i;
    cur.pierdere = dist(prv[i], i) + dist(i, nxt[i]) - dist(prv[i], nxt[i]);
    pq.push(cur);
}
int main() {
    #ifndef ONLINE_JUDGE
        freopen("input", "r", stdin);
    #endif

    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.precision(12);
    cout.fixed;

    int n;
    cin >> n;

    ll now = 0;
    ll cur = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        nxt[i] = i + 1;
        prv[i] = i - 1;
        if(i != 1)
            now += dist(i, i-1);
    }

    now += dist(n, 1);
    prv[1] = n;
    nxt[n] = 1;

    for(int i = 1; i <= n; ++i) {
        add(i);
    }

    vector< ll > ans(n + 1);
    for(int i = n; i > 3; --i) {

        while(deleted[pq.top().mid] || deleted[pq.top().l] || deleted[pq.top().r]) pq.pop();
        ll x, c;
        x = pq.top().mid;
        c = pq.top().pierdere;
        pq.pop();

        ans[i] = now;
        now -= c;
        deleted[x] = true;
        nxt[prv[x]] = nxt[x];
        prv[nxt[x]] = prv[x];

        add(prv[x]);
        add(nxt[x]);
     }

     ans[3] = now;
     for(int i = 3; i <= n; ++i) cout << ans[i] << ' ';
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}

typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > vll;
typedef vector< pii > vpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;

const ll MOD = 1e9 + 7;

ll lgput(ll a, ll b, ll mod) {
    ll ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return ret;
}

inline ll inv(ll x, ll MOD) {
    return lgput(x, MOD - 2, MOD);
}

const ld PI = acos(-1);
const ld eps = 1e-6;

const int MAXN = 3e5 + 10;
struct str{
    int l, mid, r;
    ll pierdere;
};

bool deleted[MAXN];
int nxt[MAXN];
int prv[MAXN];

int n;

class cmp{
public:
    const bool operator() (const str &a, const str &b) {
        return a.pierdere > b.pierdere;
    }
};
priority_queue< str, vector< str>, cmp > pq;
pair< int, int > v[MAXN];
ll dist(int i, int j) {
    return abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
}

void add(int i) {
    str cur;
    cur.l = prv[i];
    cur.r = nxt[i];
    cur.mid = i;
    cur.pierdere = dist(prv[i], i) + dist(i, nxt[i]) - dist(prv[i], nxt[i]);
    pq.push(cur);
}
int main() {
    #ifndef ONLINE_JUDGE
        freopen("input", "r", stdin);
    #endif

    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.precision(12);
    cout.fixed;

    int n;
    cin >> n;

    ll now = 0;
    ll cur = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        nxt[i] = i + 1;
        prv[i] = i - 1;
        if(i != 1)
            now += dist(i, i-1);
    }

    now += dist(n, 1);
    prv[1] = n;
    nxt[n] = 1;

    for(int i = 1; i <= n; ++i) {
        add(i);
    }

    vector< ll > ans(n + 5);
    for(int i = n; i > 3; --i) {
        while(deleted[pq.top().mid] || deleted[pq.top().l] || deleted[pq.top().r]) pq.pop();
        ll x, c;
        x = pq.top().mid;
        c = pq.top().pierdere;
        pq.pop();

        ans[i] = now;
        now -= c;
        deleted[x] = true;
        nxt[prv[i]] = nxt[i];
        prv[nxt[i]] = prv[i];

        add(prv[i]);
        add(nxt[i]);
     }

     ans[3] = now;
     for(int i = 3; i <= n; ++i) cout << ans[i] << ' ';
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define mp make_pair
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}

typedef pair< int, int > pii;
typedef pair< long long, long long > pll;
typedef long long ll;
typedef vector< int > vi;
typedef vector< ll > vll;
typedef vector< pii > vpii;
typedef vector< pll > vpll;
typedef long double ld;
typedef vector< ld > vld;

const ll MOD = 1e9 + 7;

ll lgput(ll a, ll b, ll mod) {
    ll ret = 1;
    while( b ){
        if(b & 1) ret = (ret * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }

    return ret;
}

inline ll inv(ll x, ll MOD) {
    return lgput(x, MOD - 2, MOD);
}

const ld PI = acos(-1);
const ld eps = 1e-6;

const int MAXN = 3e5 + 10;
struct str{
    int l, mid, r;
    ll pierdere;
};

bool deleted[MAXN];
int nxt[MAXN];
int prv[MAXN];

class cmp{
public:
    const bool operator() (const str &a, const str &b) {
        if(a.pierdere == b.pierdere) return a.mid < b.mid;
        return a.pierdere > b.pierdere;
    }
};
priority_queue< str, vector< str>, cmp > pq;
pair< int, int > v[MAXN];
ll dist(int i, int j) {
    return abs(v[i].first - v[j].first) + abs(v[i].second - v[j].second);
}

void add(int i) {
    str cur;
    cur.l = prv[i];
    cur.r = nxt[i];
    cur.mid = i;
    cur.pierdere = dist(prv[i], i) + dist(i, nxt[i]) - dist(prv[i], nxt[i]);
    pq.push(cur);
}
int main() {
    #ifndef ONLINE_JUDGE
        freopen("input", "r", stdin);
    #endif

    srand(time(NULL));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.precision(12);
    cout.fixed;

    int n;
    cin >> n;

    ll now = 0;
    ll cur = 0;
    for(int i = 1; i <= n; ++i) {
        cin >> v[i].first >> v[i].second;
        nxt[i] = i + 1;
        prv[i] = i - 1;
        if(i != 1)
            now += dist(i, i-1);
    }

    now += dist(n, 1);
    prv[1] = n;
    nxt[n] = 1;

    for(int i = 1; i <= n; ++i) {
        add(i);
    }

    vector< ll > ans(n + 5);
    for(int i = n; i > 3; --i) {

        while(prv[pq.top().mid] != pq.top().l || nxt[pq.top().mid] != pq.top().r) pq.pop();
        ll x, c;
        x = pq.top().mid;
        c = pq.top().pierdere;
        pq.pop();

        ans[i] = now;
        now -= c;
        nxt[prv[x]] = nxt[x];
        prv[nxt[x]] = prv[x];

        add(prv[x]);
        add(nxt[x]);
     }

     ans[3] = now;
     for(int i = 3; i <= n; ++i) cout << ans[i] << ' ';
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

#define N 300300

int n, x[N], y[N];

int dist(int i, int j) {
    return abs(x[i] - x[j]) + abs(y[i] - y[j]);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d %d", &x[i], &y[i]);
    int mx = 0, mn = 1e9, rlt = 0; vector <int> vec;
    for (int i = 0; i < n; i ++) mx = max(mx, x[i]), mn = min(mn, x[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (x[i] == mn || x[i] == mx) vec.push_back(i);
    mx = 0, mn = 1e9;
    for (int i = 0; i < n; i ++) mx = max(mx, y[i]), mn = min(mn, y[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (y[i] == mn || y[i] == mx) vec.push_back(i);
    int sz = vec.size(), ans = 0;
    for (int i = 0; i < sz; i ++)
        for (int j = 0; j < i; j ++)
            for (int k = 0; k < j; k ++)
                ans = max(ans, dist(i, j) + dist(j, k) + dist(k, i));
    printf("%d", ans);
    for (int i = 3; i < n; i ++) printf(" %d", rlt); puts("");
}


#include <bits/stdc++.h>
using namespace std;

#define N 300300

int n, x[N], y[N];

int dist(int i, int j) {
    return abs(x[i] - x[j]) + abs(y[i] - y[j]);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d %d", &x[i], &y[i]);
    int mx = 0, mn = 1e9, rlt = 0; vector <int> vec;
    for (int i = 0; i < n; i ++) mx = max(mx, x[i]), mn = min(mn, x[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (x[i] == mn || x[i] == mx) vec.push_back(i);
    mx = 0, mn = 1e9;
    for (int i = 0; i < n; i ++) mx = max(mx, y[i]), mn = min(mn, y[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (y[i] == mn || y[i] == mx) vec.push_back(i);
    int sz = vec.size(), ans = 0;
    for (int i = 0; i < sz; i ++)
        for (int j = 0; j <= i; j ++)
            for (int k = 0; k < n; k ++)
                ans = max(ans, dist(vec[i], vec[j]) + dist(vec[j], k) + dist(k, vec[i]));
    printf("%d", ans);
    for (int i = 3; i < n; i ++) printf(" %d", rlt); puts("");
}


#include <bits/stdc++.h>
using namespace std;

#define N 300300

int n, x[N], y[N];

int dist(int i, int j) {
    return abs(x[i] - x[j]) + abs(y[i] - y[j]);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d %d", &x[i], &y[i]);
    int mx = 0, mn = 1e9, rlt = 0; vector <int> vec;
    for (int i = 0; i < n; i ++) mx = max(mx, x[i]), mn = min(mn, x[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (x[i] == mn || x[i] == mx) vec.push_back(i);
    mx = 0, mn = 1e9;
    for (int i = 0; i < n; i ++) mx = max(mx, y[i]), mn = min(mn, y[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (y[i] == mn || y[i] == mx) vec.push_back(i);
    int sz = vec.size(), ans = 0;
    for (int i = 0; i < sz; i ++)
        for (int j = 0; j <= i; j ++)
            for (int k = 0; k <= j; k ++)
                ans = max(ans, dist(i, j) + dist(j, k) + dist(k, i));
    printf("%d", ans);
    for (int i = 3; i < n; i ++) printf(" %d", rlt); puts("");
}


#include <bits/stdc++.h>
using namespace std;

#define N 300300

int n, x[N], y[N];

int dist(int i, int j) {
    return abs(x[i] - x[j]) + abs(y[i] - y[j]);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i ++) scanf("%d %d", &x[i], &y[i]);
    int mx = -1e9, mn = 1e9, rlt = 0; vector <int> vec;
    for (int i = 0; i < n; i ++) mx = max(mx, x[i]), mn = min(mn, x[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (x[i] == mn || x[i] == mx) vec.push_back(i);
    mx = -1e9, mn = 1e9;
    for (int i = 0; i < n; i ++) mx = max(mx, y[i]), mn = min(mn, y[i]);
    rlt += 2 * (mx - mn);
    for (int i = 0; i < n; i ++) if (y[i] == mn || y[i] == mx) vec.push_back(i);
    int sz = vec.size(), ans = 0;
    for (int i = 0; i < sz; i ++)
        for (int j = 0; j <= i; j ++)
            for (int k = 0; k < n; k ++)
                ans = max(ans, dist(vec[i], vec[j]) + dist(vec[j], k) + dist(k, vec[i]));
    printf("%d", ans);
    for (int i = 3; i < n; i ++) printf(" %d", rlt); puts("");
}


#include<bits/stdc++.h>

using namespace std;

vector<int> vertx;
vector<int> verty;

int odl(int a, int b){
    return abs(vertx[a]-vertx[b])+abs(verty[a]-verty[b]);
}

int licz(int p1, int p2, int p3){
    return odl(p1, p2)+odl(p2, p3)+ odl(p3, p1);
}

int main(){
    ios_base::sync_with_stdio(0);
    int n;cin>>n;

    int minx=1000000001;
    int maxx=-1000000001;
    int miny=1000000001;
    int maxy=-1000000001;
    int minxpos=-1;
    int maxxpos=-1;
    int minypos=-1;
    int maxypos=-1;

    int minxpos2=-1;
    int maxxpos2=-1;
    int minxpos3=-1;
    int maxxpos3=-1;

    for(int i=0;i<n;++i){
        int a, b;cin>>a>>b;
        vertx.push_back(a);
        verty.push_back(b);
        if(a<minx){
            minx=a;
            minxpos=i;
            minxpos2=i;
            minxpos3=i;
        }
        else if(a==minx){
            if(verty[i]<verty[minxpos2])minxpos2=i;
            if(verty[i]>verty[minxpos3])minxpos3=i;
        }

        if(a>maxx){
            maxx=a;
            maxxpos=i;
            maxxpos2=i;
            maxxpos3=i;
        }
        else if(a==maxx){
            if(verty[i]<verty[maxxpos2])maxxpos2=i;
            if(verty[i]>verty[maxxpos3])maxxpos3=i;
        }

        if(b<miny){
            miny=b;
            minypos=i;
        }
        if(b>maxy){
            maxypos=i;
            maxy=b;
        }

    }

    int ccc=0;
    int p1=minxpos;
    int p2=minypos;
    int p3=maxxpos;
    int p4=maxypos;
    if(verty[maxxpos2]==miny){p2=maxxpos2;p3=p4;}
    else if(verty[maxxpos3]==maxy)p3=maxxpos3;
    else if(verty[minxpos2]==miny){p1=minxpos2;p2=p4;}
    else if(verty[minxpos3]==maxy)p1=minxpos3;
    else{

        int ret=licz(p1, p2, p3);
        ret=max(licz(p1, p2, p4), ret);
        ret=max(licz(p1, p3, p4), ret);
        ret=max(licz(p2, p3, p4), ret);

        for(int i=0;i<n;++i){
            ret=max(licz(i, p2, p3), ret);
            ret=max(licz(i, p2, p4), ret);
            ret=max(licz(i, p3, p4), ret);
            ret=max(licz(i, p3, p4), ret);
            ret=max(licz(p1, i, p3), ret);
            ret=max(licz(p1, i, p4), ret);
            ret=max(licz(p1, i, p4), ret);
            ret=max(licz(p2, i, p4), ret);
            ret=max(licz(p1, p2, i), ret);
            ret=max(licz(p1, p2, i), ret);
            ret=max(licz(p1, p3, i), ret);
            ret=max(licz(p2, p3, i), ret);
        }

        cout<<ret<<" ";
        ccc=1;
    }
    int ret2=odl(p1, p2)+odl(p2, p3)+ odl(p3, p4)+odl(p4, p1);
    for(int i=3+ccc;i<=n;++i){
        cout<<ret2<<" ";
    }

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

vector<int> vertx;
vector<int> verty;

int odl(int a, int b){
    return abs(vertx[a]-vertx[b])+abs(verty[a]-verty[b]);
}

int licz(int p1, int p2, int p3){
    return odl(p1, p2)+odl(p2, p3)+ odl(p3, p1);
}

int main(){
    ios_base::sync_with_stdio(0);
    int n;cin>>n;

    int minx=1000000001;
    int maxx=-1000000001;
    int miny=1000000001;
    int maxy=-1000000001;
    int minxpos=-1;
    int maxxpos=-1;
    int minypos=-1;
    int maxypos=-1;

    int minxpos2=-1;
    int maxxpos2=-1;
    int minxpos3=-1;
    int maxxpos3=-1;

    for(int i=0;i<n;++i){
        int a, b;cin>>a>>b;
        vertx.push_back(a);
        verty.push_back(b);
        if(a<minx){
            minx=a;
            minxpos=i;
            minxpos2=i;
            minxpos3=i;
        }
        else if(a==minx){
            if(verty[i]<verty[minxpos2])minxpos2=i;
            if(verty[i]>verty[minxpos3])minxpos3=i;
        }

        if(a>maxx){
            maxx=a;
            maxxpos=i;
            maxxpos2=i;
            maxxpos3=i;
        }
        else if(a==maxx){
            if(verty[i]<verty[maxxpos2])maxxpos2=i;
            if(verty[i]>verty[maxxpos3])maxxpos3=i;
        }

        if(b<miny){
            miny=b;
            minypos=i;
        }
        if(b>maxy){
            maxypos=i;
            maxy=b;
        }

    }

    int p1=minxpos;
    int p2=minypos;
    int p3=maxxpos;
    int p4=maxypos;
    if(verty[maxxpos2]==miny){p2=maxxpos2;p3=p4;}
    else if(verty[maxxpos3]==maxy)p3=maxxpos3;
    else if(verty[minxpos2]==miny){p1=minxpos2;p2=p4;}
    else if(verty[minxpos3]==maxy)p1=minxpos3;

    int ret=licz(p1, p2, p3);
    ret=max(licz(p1, p2, p4), ret);
    ret=max(licz(p1, p3, p4), ret);
    ret=max(licz(p2, p3, p4), ret);
    int ret2=odl(p1, p2)+odl(p2, p3)+ odl(p3, p4)+odl(p4, p1);
    cout<<ret<<" ";
    for(int i=4;i<=n;++i){
        cout<<ret2<<" ";
    }

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

vector<int> vertx;
vector<int> verty;

int odl(int a, int b){
    return abs(vertx[a]-vertx[b])+abs(verty[a]-verty[b]);
}

int licz(int p1, int p2, int p3){
    return odl(p1, p2)+odl(p2, p3)+ odl(p3, p1);
}

int main(){
    ios_base::sync_with_stdio(0);
    int n;cin>>n;

    int minx=1000000001;
    int maxx=-1000000001;
    int miny=1000000001;
    int maxy=-1000000001;
    int minxpos=-1;
    int maxxpos=-1;
    int minypos=-1;
    int maxypos=-1;

    int minxpos2=-1;
    int maxxpos2=-1;
    int minxpos3=-1;
    int maxxpos3=-1;

    for(int i=0;i<n;++i){
        int a, b;cin>>a>>b;
        vertx.push_back(a);
        verty.push_back(b);
        if(a<minx){
            minx=a;
            minxpos=i;
            minxpos2=i;
            minxpos3=i;
        }
        else if(a==minx){
            if(verty[i]<verty[minxpos2])minxpos2=i;
            if(verty[i]>verty[minxpos3])minxpos3=i;
        }

        if(a>maxx){
            maxx=a;
            maxxpos=i;
            maxxpos2=i;
            maxxpos3=i;
        }
        else if(a==maxx){
            if(verty[i]<verty[maxxpos2])maxxpos2=i;
            if(verty[i]>verty[maxxpos3])maxxpos3=i;
        }

        if(b<miny){
            miny=b;
            minypos=i;
        }
        if(b>maxy){
            maxypos=i;
            maxy=b;
        }

    }

    int ccc=0;
    int p1=minxpos;
    int p2=minypos;
    int p3=maxxpos;
    int p4=maxypos;

        int ret=licz(p1, p2, p3);
        ret=max(licz(p1, p2, p4), ret);
        ret=max(licz(p1, p3, p4), ret);
        ret=max(licz(p2, p3, p4), ret);

        for(int i=0;i<n;++i){
            ret=max(licz(i, p1, p2), ret);
            ret=max(licz(i, p1, p3), ret);
            ret=max(licz(i, p1, p4), ret);
            ret=max(licz(i, p2, p3), ret);
            ret=max(licz(i, p2, p4), ret);
            ret=max(licz(i, p3, p4), ret);
        }

        cout<<ret<<" ";
        ccc=1;

    int ret2=odl(p1, p2)+odl(p2, p3)+ odl(p3, p4)+odl(p4, p1);
    for(int i=3+ccc;i<=n;++i){
        cout<<ret2<<" ";
    }

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

vector<int> vertx;
vector<int> verty;

int odl(int a, int b){
    return abs(vertx[a]-vertx[b])+abs(verty[a]-verty[b]);
}

int licz(int p1, int p2, int p3){
    return odl(p1, p2)+odl(p2, p3)+ odl(p3, p1);
}

int main(){
    ios_base::sync_with_stdio(0);
    int n;cin>>n;

    int minx=1000000001;
    int maxx=-1000000001;
    int miny=1000000001;
    int maxy=-1000000001;
    int minxpos=-1;
    int maxxpos=-1;
    int minypos=-1;
    int maxypos=-1;

    int minxpos2=-1;
    int maxxpos2=-1;
    int minxpos3=-1;
    int maxxpos3=-1;

    for(int i=0;i<n;++i){
        int a, b;cin>>a>>b;
        vertx.push_back(a);
        verty.push_back(b);
        if(a<minx){
            minx=a;
            minxpos=i;
            minxpos2=i;
            minxpos3=i;
        }
        else if(a==minx){
            if(verty[i]<verty[minxpos2])minxpos2=i;
            if(verty[i]>verty[minxpos3])minxpos3=i;
        }

        if(a>maxx){
            maxx=a;
            maxxpos=i;
            maxxpos2=i;
            maxxpos3=i;
        }
        else if(a==maxx){
            if(verty[i]<verty[maxxpos2])maxxpos2=i;
            if(verty[i]>verty[maxxpos3])maxxpos3=i;
        }

        if(b<miny){
            miny=b;
            minypos=i;
        }
        if(b>maxy){
            maxypos=i;
            maxy=b;
        }

    }

    int ccc=0;
    int p1=minxpos;
    int p2=minypos;
    int p3=maxxpos;
    int p4=maxypos;
    if(verty[maxxpos2]==miny){p2=maxxpos2;p3=p4;}
    else if(verty[maxxpos3]==maxy)p3=maxxpos3;
    else if(verty[minxpos2]==miny){p1=minxpos2;p2=p4;}
    else if(verty[minxpos3]==maxy)p1=minxpos3;
    else{

        int ret=licz(p1, p2, p3);
        ret=max(licz(p1, p2, p4), ret);
        ret=max(licz(p1, p3, p4), ret);
        ret=max(licz(p2, p3, p4), ret);

        for(int i=0;i<n;++i){
            ret=max(licz(i, p2, p3), ret);
            ret=max(licz(i, p2, p4), ret);
            ret=max(licz(i, p3, p4), ret);
            ret=max(licz(i, p3, p4), ret);
            ret=max(licz(p1, i, p3), ret);
            ret=max(licz(p1, i, p4), ret);
            ret=max(licz(p1, i, p4), ret);
            ret=max(licz(p2, i, p4), ret);
            ret=max(licz(p1, p2, i), ret);
            ret=max(licz(p1, p2, i), ret);
            ret=max(licz(p1, p3, i), ret);
            ret=max(licz(p2, p3, i), ret);
        }

        cout<<ret<<" ";
        ccc=1;
    }
    int ret2=odl(p1, p2)+odl(p2, p3)+ odl(p3, p4)+odl(p4, p1);
    for(int i=4-ccc;i<=n;++i){
        cout<<ret2<<" ";
    }

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

vector<int> vertx;
vector<int> verty;

int odl(int a, int b){
    return abs(vertx[a]-vertx[b])+abs(verty[a]-verty[b]);
}

int licz(int p1, int p2, int p3){
    return odl(p1, p2)+odl(p2, p3)+ odl(p3, p1);
}

int main(){
    ios_base::sync_with_stdio(0);
    int n;cin>>n;

    int minx=1000000001;
    int maxx=-1000000001;
    int miny=1000000001;
    int maxy=-1000000001;
    int minxpos=-1;
    int maxxpos=-1;
    int minypos=-1;
    int maxypos=-1;

    int minxpos2=-1;
    int maxxpos2=-1;
    int minxpos3=-1;
    int maxxpos3=-1;

    for(int i=0;i<n;++i){
        int a, b;cin>>a>>b;
        vertx.push_back(a);
        verty.push_back(b);
        if(a<minx){
            minx=a;
            minxpos=i;
            minxpos2=i;
            minxpos3=i;
        }
        else if(a==minx){
            if(verty[i]<verty[minxpos2])minxpos2=i;
            if(verty[i]>verty[minxpos3])minxpos3=i;
        }

        if(a>maxx){
            maxx=a;
            maxxpos=i;
            maxxpos2=i;
            maxxpos3=i;
        }
        else if(a==maxx){
            if(verty[i]<verty[maxxpos2])maxxpos2=i;
            if(verty[i]>verty[maxxpos3])maxxpos3=i;
        }

        if(b<miny){
            miny=b;
            minypos=i;
        }
        if(b>maxy){
            maxypos=i;
            maxy=b;
        }

    }

    int ccc=0;
    int p1=minxpos;
    int p2=minypos;
    int p3=maxxpos;
    int p4=maxypos;
    if(verty[maxxpos2]==miny){p2=maxxpos2;p3=p4;}
    else if(verty[maxxpos3]==maxy)p3=maxxpos3;
    else if(verty[minxpos2]==miny){p1=minxpos2;p2=p4;}
    else if(verty[minxpos3]==maxy)p1=minxpos3;
    else{

        int ret=licz(p1, p2, p3);
        ret=max(licz(p1, p2, p4), ret);
        ret=max(licz(p1, p3, p4), ret);
        ret=max(licz(p2, p3, p4), ret);

        for(int i=0;i<n;++i){
            ret=max(licz(i, p1, p2), ret);
            ret=max(licz(i, p1, p3), ret);
            ret=max(licz(i, p1, p4), ret);
            ret=max(licz(i, p2, p3), ret);
            ret=max(licz(i, p2, p4), ret);
            ret=max(licz(i, p3, p4), ret);
        }

        cout<<ret<<" ";
        ccc=1;
    }
    int ret2=odl(p1, p2)+odl(p2, p3)+ odl(p3, p4)+odl(p4, p1);
    for(int i=3+ccc;i<=n;++i){
        cout<<ret2<<" ";
    }

    return 0;
}


#include <stdio.h>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <complex>
#include <map>
#include <queue>
#include <array>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef long double ld;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<pii> vii;
typedef vector<string> vs;
//typedef long long int;

int dist(const pii& a, const pii& b) {
  return abs(a.first - b.first) + abs(a.second - b.second);
}

int per(const pii& a, const pii& b, const pii& c) {
  return dist(a, b) + dist(b, c) + dist(a, c);
}

int per(const array<int, 3>& ind, const vii& p) {
  return per(p[ind[0]], p[ind[1]], p[ind[2]]);
}

int nx(int i, int n) {
  i += 1;
  if (i >= n) i -= n;
  return i;
}

int pr(int i, int n) {
  i -= 1;
  if (i < 0) i += n;
  return i;
}

void local(array<int, 3>& ind, int& P, const vii& p) {
  int n = p.size();
  while (1) {
    int P0 = P;
    for (int i = 0; i < 3; ++i) {
      while (1) {
        ind[i] = nx(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = pr(ind[i], n);
          break;
        }
      }
      while (1) {
        ind[i] = pr(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = nx(ind[i], n);
          break;
        }
      }
    }
    if (P0 == P) break;
  }
}

int stupid(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int i = 0; i < n; ++i) for (int j = i; j < n; ++j) for (int l = j; l < n; ++l) {
    res = max(res, per({i, j, l}, p));
  }
  return res;
}

int calcp3(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int t = 0; t < 30; ++t) {
    int a = rand() % n;
    int b = a, c = a;
    while (b == a) b = rand() % n;
    while (c == a || c == b) c = rand() % n;
    int P = per(p[a], p[b], p[c]);
    array<int, 3> ind = {a, b, c};
    sort(ind.begin(), ind.end());
    local(ind, P, p);
    res = max(res, P);
    auto ind0 = ind;
    for (int i = 0; i < 3; ++i) {
      ind = ind0;
      ind[i] = nx(ind[(i + 1) % 3], n);
      swap(ind[0], ind[i]);
      P = per(ind, p);
      local(ind, P, p);
      res = max(res, P);
    }
  }
  if (n <= 100) {
    assert(res == stupid(p));
  }
  return res;
}

int main() {
  srand(3471293857426578924165789241658712465897612487956247831426589724);
  std::ios::sync_with_stdio(false); std::cin.tie(0);
  int n;
  cin >> n;
  vii p(n);
  int minx = 1e9, miny = 1e9, maxx = -1e9, maxy = -1e9;
  for (int i = 0; i < n; ++i) {
    cin >> p[i].first >> p[i].second;
    minx = min(minx, p[i].first);
    maxx = max(maxx, p[i].first);
    miny = min(miny, p[i].second);
    maxy = max(maxy, p[i].second);
  }
  cout << calcp3(p);
  for (int i = 4; i <= n; ++i) {
    cout << ' ' << 2 * (maxx - minx + maxy - miny);
  }
  cout << endl;
  return 0;
}


#include <stdio.h>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <complex>
#include <map>
#include <queue>
#include <array>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef long double ld;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<pii> vii;
typedef vector<string> vs;
//typedef long long int;

int dist(const pii& a, const pii& b) {
  return abs(a.first - b.first) + abs(a.second - b.second);
}

int per(const pii& a, const pii& b, const pii& c) {
  return dist(a, b) + dist(b, c) + dist(a, c);
}

int per(const array<int, 3>& ind, const vii& p) {
  return per(p[ind[0]], p[ind[1]], p[ind[2]]);
}

int nx(int i, int n) {
  i += 1;
  if (i >= n) i -= n;
  return i;
}

int pr(int i, int n) {
  i -= 1;
  if (i < 0) i += n;
  return i;
}

void local(array<int, 3>& ind, int& P, const vii& p) {
  int n = p.size();
  while (1) {
    int P0 = P;
    for (int i = 0; i < 3; ++i) {
      while (1) {
        ind[i] = nx(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = pr(ind[i], n);
          break;
        }
      }
      while (1) {
        ind[i] = pr(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = nx(ind[i], n);
          break;
        }
      }
    }
    if (P0 == P) break;
  }
}

int stupid(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int i = 0; i < n; ++i) for (int j = i; j < n; ++j) for (int l = j; l < n; ++l) {
    res = max(res, per({i, j, l}, p));
  }
  return res;
}

int calcp3(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int t = 0; t < 10; ++t) {
    int a = rand() % n;
    int b = a, c = a;
    while (b == a) b = rand() % n;
    while (c == a || c == b) c = rand() % n;
    int P = per(p[a], p[b], p[c]);
    array<int, 3> ind = {a, b, c};
    sort(ind.begin(), ind.end());
    local(ind, P, p);
    res = max(res, P);
    while (true) {
      for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < n; ++j) {
          int prev = ind[i];
          ind[i] = j;
          int curP = per(ind, p);
          if (curP > P) {
            P = curP;
          } else {
            ind[i] = prev;
          }
        }
      }
      local(ind, P, p);
      if (res == P) break;
      res = max(res, P);
    }
/*    auto ind0 = ind;
    for (int i = 0; i < 3; ++i) {
      ind = ind0;
      ind[i] = nx(ind[(i + 1) % 3], n);
      swap(ind[0], ind[i]);
      P = per(ind, p);
      local(ind, P, p);
      res = max(res, P);
    }*/
  }
  if (n <= 100) {
    assert(res == stupid(p));
  }
  return res;
}

int main() {
  srand(3471293857426578924165789241658712465897612487956247831426589724);
  std::ios::sync_with_stdio(false); std::cin.tie(0);
  int n;
  cin >> n;
  vii p(n);
  int minx = 1e9, miny = 1e9, maxx = -1e9, maxy = -1e9;
  for (int i = 0; i < n; ++i) {
    cin >> p[i].first >> p[i].second;
    minx = min(minx, p[i].first);
    maxx = max(maxx, p[i].first);
    miny = min(miny, p[i].second);
    maxy = max(maxy, p[i].second);
  }
  cout << calcp3(p);
  for (int i = 4; i <= n; ++i) {
    cout << ' ' << 2 * (maxx - minx + maxy - miny);
  }
  cout << endl;
  return 0;
}


#include <stdio.h>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <complex>
#include <map>
#include <queue>
#include <array>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef long double ld;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<pii> vii;
typedef vector<string> vs;
//typedef long long int;

int dist(const pii& a, const pii& b) {
  return abs(a.first - b.first) + abs(a.second - b.second);
}

int per(const pii& a, const pii& b, const pii& c) {
  return dist(a, b) + dist(b, c) + dist(a, c);
}

int per(const array<int, 3>& ind, const vii& p) {
  return per(p[ind[0]], p[ind[1]], p[ind[2]]);
}

int nx(int i, int n) {
  i += 1;
  if (i >= n) i -= n;
  return i;
}

int pr(int i, int n) {
  i -= 1;
  if (i < 0) i += n;
  return i;
}

void local(array<int, 3>& ind, int& P, const vii& p) {
  int n = p.size();
  while (1) {
    int P0 = P;
    for (int i = 0; i < 3; ++i) {
      while (1) {
        ind[i] = nx(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = pr(ind[i], n);
          break;
        }
      }
      while (1) {
        ind[i] = pr(ind[i], n);
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = nx(ind[i], n);
          break;
        }
      }
    }
    if (P0 == P) break;
  }
}

int stupid(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int i = 0; i < n; ++i) for (int j = i; j < n; ++j) for (int l = j; l < n; ++l) {
    res = max(res, per({i, j, l}, p));
  }
  return res;
}

int calcp3(const vii& p) {
  int n = p.size();
  int res = 0;
  for (int t = 0; t < 10; ++t) {
    int a = rand() % n;
    int b = a, c = a;
    while (b == a) b = rand() % n;
    while (c == a || c == b) c = rand() % n;
    int P = per(p[a], p[b], p[c]);
    array<int, 3> ind = {a, b, c};
    sort(ind.begin(), ind.end());
    local(ind, P, p);
    res = max(res, P);
    for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < n; ++j) {
        int prev = ind[i];
        ind[i] = j;
        int curP = per(ind, p);
        if (curP > P) {
          P = curP;
        } else {
          ind[i] = prev;
        }
      }
    }
    local(ind, P, p);
    res = max(res, P);
/*    auto ind0 = ind;
    for (int i = 0; i < 3; ++i) {
      ind = ind0;
      ind[i] = nx(ind[(i + 1) % 3], n);
      swap(ind[0], ind[i]);
      P = per(ind, p);
      local(ind, P, p);
      res = max(res, P);
    }*/
  }
  if (n <= 100) {
    assert(res == stupid(p));
  }
  return res;
}

int main() {
  srand(3471293857426578924165789241658712465897612487956247831426589724);
  std::ios::sync_with_stdio(false); std::cin.tie(0);
  int n;
  cin >> n;
  vii p(n);
  int minx = 1e9, miny = 1e9, maxx = -1e9, maxy = -1e9;
  for (int i = 0; i < n; ++i) {
    cin >> p[i].first >> p[i].second;
    minx = min(minx, p[i].first);
    maxx = max(maxx, p[i].first);
    miny = min(miny, p[i].second);
    maxy = max(maxy, p[i].second);
  }
  vi good;
  for (int i = 0; i < n; ++i) {
    if (p[i].first == minx || p[i].first == maxx || p[i].second == miny || p[i].second == maxy) {
      good.push_back(i);
    }
  }
  int res3 = calcp3(p);
  for (int i = 0; i < (int)good.size(); ++i) for (int j = i + 1; j < (int)good.size(); ++j) {
    for (int l = 0; l < n; ++l) {
      res3 = max(res3, per({good[i], good[j], l}, p));
    }
  }
  cout << res3;
  for (int i = 4; i <= n; ++i) {
    cout << ' ' << 2 * (maxx - minx + maxy - miny);
  }
  cout << endl;
  return 0;
}


#include <bits/stdc++.h>

#define debug(x) cout << #x << " = " << x << endl
#define fori(i, ini, lim) for(int i = int(ini); i < int(lim); i++)
#define ford(i, ini, lim) for(int i = int(ini); i >= int(lim); i--)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;

const int INF = (int) 1e9;

int main() {
    int n;
    scanf("%d", &n);
    int min_x = INF, max_x = -INF, min_y = INF, max_y = -INF;
    int max_sum = -INF;
    int max_diff = -INF;
    vector<ii> v(n);
    fori(i, 0, n) {
        scanf("%d %d", &v[i].first, &v[i].second);
        min_x = min(min_x, v[i].first);
        max_x = max(max_x, v[i].first);
        min_y = min(min_y, v[i].second);
        max_y = max(max_y, v[i].second);
        max_sum = max(max_sum, v[i].first + v[i].second);
        max_diff = max(max_diff, v[i].first - v[i].second);
    }
    int f3 = 0;
    fori(i, 0, n) {
        int x, y;
        tie(x, y) = v[i];
        f3 = max(f3, max_sum - (x + min_y));
        f3 = max(f3, (max_y - x) + max_diff);
        f3 = max(f3, (max_x - x) + (y - min_y));
        f3 = max(f3, (max_x - x) + (max_y - y));
    }
    f3 *= 2;
    printf("%d", f3);
    int f4 = 2 * (max_x - min_x + max_y - min_y);
    fori(i, 4, n + 1) {
        printf(" %d", f4);
    }
    puts("");
    return 0;
}


#include <bits/stdc++.h>

#define debug(x) cout << #x << " = " << x << endl
#define fori(i, ini, lim) for(int i = int(ini); i < int(lim); i++)
#define ford(i, ini, lim) for(int i = int(ini); i >= int(lim); i--)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;

const int INF = (int) 1e9;

int main() {
    int n;
    scanf("%d", &n);
    int min_x = INF, max_x = -INF, min_y = INF, max_y = -INF;
    int max_sum = -INF;
    int max_diff = -INF;
    vector<ii> v(n);
    fori(i, 0, n) {
        scanf("%d %d", &v[i].first, &v[i].second);
        min_x = min(min_x, v[i].first);
        max_x = max(max_x, v[i].first);
        min_y = min(min_y, v[i].second);
        max_y = max(max_y, v[i].second);
        max_sum = max(max_sum, v[i].first + v[i].second);
        max_diff = max(max_diff, v[i].first - v[i].second);
    }
    int f3 = 0;
    fori(i, 0, n) {
        int x, y;
        tie(x, y) = v[i];
        int cur_min_x = x;
        f3 = max(f3, max_sum - (cur_min_x - min_y));
        f3 = max(f3, (max_y - cur_min_x) + max_diff);
    }
    f3 *= 2;
    printf("%d", f3);
    int f4 = 2 * (max_x - min_x + max_y - min_y);
    fori(i, 4, n + 1) {
        printf(" %d", f4);
    }
    puts("");
    return 0;
}


#include <bits/stdc++.h>

#define debug(x) cout << #x << " = " << x << endl
#define fori(i, ini, lim) for(int i = int(ini); i < int(lim); i++)
#define ford(i, ini, lim) for(int i = int(ini); i >= int(lim); i--)

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;

const int INF = (int) 1e9;

int main() {
    int n;
    scanf("%d", &n);
    int min_x = INF, max_x = -INF, min_y = INF, max_y = -INF;
    int max_sum = -INF;
    int max_diff = -INF;
    vector<ii> v(n);
    fori(i, 0, n) {
        scanf("%d %d", &v[i].first, &v[i].second);
        min_x = min(min_x, v[i].first);
        max_x = max(max_x, v[i].first);
        min_y = min(min_y, v[i].second);
        max_y = max(max_y, v[i].second);
        max_sum = max(max_sum, v[i].first + v[i].second);
        max_diff = max(max_diff, v[i].first - v[i].second);
    }
    int f3 = 0;
    fori(i, 0, n) {
        int x, y;
        tie(x, y) = v[i];
        int cur_min_x = x;
        f3 = max(f3, max_sum - (cur_min_x + min_y));
        f3 = max(f3, (max_y - cur_min_x) + max_diff);
    }
    f3 *= 2;
    printf("%d", f3);
    int f4 = 2 * (max_x - min_x + max_y - min_y);
    fori(i, 4, n + 1) {
        printf(" %d", f4);
    }
    puts("");
    return 0;
}


#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <utility>
#include <stack>
#include <queue>
#include <set>
#include <list>
#include <bitset>
#include <array>
using namespace std;

#define x first
#define y second
#define fi first
#define se second
#define long long long
typedef pair<int,int> point;

int n;
int ans[300003];
point A[300003];
vector<point> vec;

int state(int x) {return (x < 0)? -1 : +1;}

int main()
{
	// ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	// freopen("input.in", "r", stdin);

	scanf("%d", &n);
	for(int i = 0; i < n; i++) scanf("%d %d", &A[i].fi, &A[i].se);
	for(int i = 0; i < n; i++)
	{
		int nxt = (i+1)%n;
		int bck = (i-1+n)%n;
		if(state(A[i].x-A[bck].x) != state(A[nxt].x-A[i].x) || state(A[i].y-A[bck].y) != state(A[nxt].y-A[i].y))
			vec.push_back(A[i]);
	}
	int nn = vec.size();

	if(vec.size() <= 3)
	{
		for(int i = 0; i < nn; i++)
			ans[3] += abs(vec[i].x-vec[(i+1)%nn].x) + abs(vec[i].y-vec[(i+1)%nn].y);
		ans[4] = ans[3];
	}
	else
	{
		for(int i = 0; i < nn; i++)
			ans[4] += abs(vec[i].x-vec[(i+1)%nn].x) + abs(vec[i].y-vec[(i+1)%nn].y);

		for(int i = 0; i < nn; i++)
		{
			for(int j = i+1; j < nn; j++)
			{
				for(int k = 0; k < n; k++)
				{
					if(A[k] == vec[i] || A[k] == vec[j]) continue;
					else
					{
						int b1 = max({A[k].x,vec[i].x,vec[j].x}) - min({A[k].x,vec[i].x,vec[j].x});
						int b2 = max({A[k].y,vec[i].y,vec[j].y}) - min({A[k].y,vec[i].y,vec[j].y});
						ans[3] = max(ans[3], 2*(b1+b2));
					}
				}
			}
		}
	}

	for(int i = 5; i <= n; i++)
			ans[i] = ans[4];

	for(int i = 3; i <= n; i++) printf("%d%c", ans[i], (i == n)? '\n' : ' ');
	// for(int i = 0; i < vec.size(); i++) printf("%d %d\n", vec[i].x, vec[i].y);
}


#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <utility>
#include <stack>
#include <queue>
#include <set>
#include <list>
#include <bitset>
#include <array>
using namespace std;

#define fi first
#define se second
#define long long long
typedef pair<int,int> ii;

int n, m;
vector<int> ver, hor;

int main()
{
	// ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	// freopen("input.in", "r", stdin);

	scanf("%d %d", &n, &m);

	for(int i = 0; i < n; i++)
	{
		int x; scanf("%d", &x);
		hor.push_back(x);
	}
	sort(hor.begin(), hor.end());
	hor.push_back(1e9);

	for(int i = 0; i < m; i++)
	{
		int x1, x2, y;
		scanf("%d %d %d", &x1, &x2, &y);
		if(x1 == 1) ver.push_back(x2);
	}
	sort(ver.begin(), ver.end());

	int idx = 0;
	int mn = 1e9;
	for(int i = 0; i < hor.size(); i++)
	{
		while(idx < ver.size() && ver[idx] < hor[i])
			++idx;

		mn = min((int)ver.size()-idx + i, mn);

		// if(idx < ver.size()) printf("%d %d %d %d\n", i, idx, hor[i], ver[idx]);
		// else printf("%d %d %d\n", i, idx, hor[i]);
	}
	printf("%d\n", mn);
}


#include <bits/stdc++.h>
using namespace std;

long long X[300005], Y[300005];
long long F[300005];

vector<int> Z;

long long getDist(int x, int y)
{
    return abs(X[x] - X[y]) + abs(Y[x] - Y[y]);
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(NULL), cout.tie(NULL);

    int N;
    cin >> N;

    for(int i=1; i<=N; i++)
        cin >> X[i] >> Y[i];

    long long ans = getDist(1, N);

    for(int i=2; i<=N; i++)
        ans += getDist(i-1, i);

    for(int i=4; i<=N; i++)
        F[i] = ans;

    int minX = *min_element(X+1, X+1+N);
    int maxX = *max_element(X+1, X+1+N);

    int minY = *min_element(Y+1, Y+1+N);
    int maxY = *max_element(Y+1, Y+1+N);

    for(int i=1; i<=N; i++)
        if(X[i] == minX || X[i] == maxX || Y[i] == minY || Y[i] == maxY)
            Z.push_back(i);

    if(Z.size() == 2)
        F[3] = getDist(Z[0], Z[1]) * 2;
    else
    {
        for(int i=0; i<Z.size(); i++)
            for(int j=i+1; j<Z.size(); j++)
                for(int k=j+1; k<Z.size(); k++)
                    F[3] = max(F[3], getDist(Z[i], Z[j]) + getDist(Z[j], Z[k]) + getDist(Z[k], Z[i]));
    }

    for(int i=3; i<=N; i++)
        cout << F[i] << " ";

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

long long X[300005], Y[300005];
long long F[300005], memo[300005];

set<int> S;
set< pair<long long, int> > Q;

long long getDist(int x, int y)
{
    return abs(X[x] - X[y]) + abs(Y[x] - Y[y]);
}

int getPrev(int i)
{
    auto it = S.upper_bound(i);

    if(it != S.begin())
    {
        it--;
        return *it;
    }

    it = S.end();
    it--;

    return *it;
}

int getNext(int i)
{
    auto it = S.upper_bound(i);

    if(it != S.end())
        return *it;

    return *S.begin();
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(NULL), cout.tie(NULL);

    int N;
    cin >> N;

    for(int i=1; i<=N; i++)
    {
        S.insert(i);
        cin >> X[i] >> Y[i];
    }

    long long ans = 0;

    for(int i=2; i<=N; i++)
    {
        ans += getDist(i-1, i);
        Q.insert({getDist(i-1, i), i-1});
        memo[i-1] = getDist(i-1, i);
    }

    ans += getDist(1, N);
    Q.insert({getDist(1, N), N});
    memo[N] = getDist(1, N);

    F[N] = ans;

    for(int i=N-1; i>=3; i--)
    {
        auto q = Q.begin();

        ans -= q->first;
        int id = q->second;

        Q.erase(q);
        S.erase(id);

        int idL = getPrev(id);
        int idR = getNext(id);

        Q.erase({memo[idL], idL});
        memo[idL] = getDist(idL, idR);
        Q.insert({memo[idL], idL});

        F[i] = ans;
    }

    for(int i=3; i<=N; i++)
        cout << F[i] << " ";

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

long long X[300005], Y[300005];
long long F[300005];

vector<int> Z;

long long getDist(int x, int y)
{
    return abs(X[x] - X[y]) + abs(Y[x] - Y[y]);
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(NULL), cout.tie(NULL);

    int N;
    cin >> N;

    for(int i=1; i<=N; i++)
        cin >> X[i] >> Y[i];

    long long ans = getDist(1, N);

    for(int i=2; i<=N; i++)
        ans += getDist(i-1, i);

    for(int i=4; i<=N; i++)
        F[i] = ans;

    int minX = *min_element(X+1, X+1+N);
    int maxX = *max_element(X+1, X+1+N);

    int minY = *min_element(Y+1, Y+1+N);
    int maxY = *max_element(Y+1, Y+1+N);

    for(int i=1; i<=N; i++)
        if(X[i] == minX || X[i] == maxX || Y[i] == minY || Y[i] == maxY)
            Z.push_back(i);

    if(Z.size() == 2)
        F[3] = getDist(Z[0], Z[1]) * 2;
    else
    {
        for(int i=0; i<Z.size(); i++)
            for(int j=i+1; j<Z.size(); j++)
                for(int k=1; k<=N; k++)
                    if(k != Z[i] && k != Z[j])
                        F[3] = max(F[3], getDist(Z[i], Z[j]) + getDist(Z[j], k) + getDist(k, Z[i]));
    }

    for(int i=3; i<=N; i++)
        cout << F[i] << " ";

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

long long X[300005], Y[300005];
long long F[300005];

int L[300005], R[300005];

set< pair<long long, int> > Q;

long long getDist(int x, int y)
{
    return abs(X[x] - X[y]) + abs(Y[x] - Y[y]);
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(NULL), cout.tie(NULL);

    int N;
    cin >> N;

    for(int i=1; i<=N; i++)
    {
        L[i] = i-1, R[i] = i+1;
        cin >> X[i] >> Y[i];
    }

    L[1] = N, R[N] = 1;

    long long ans = 0;

    for(int i=1; i<=N; i++)
    {
        ans += getDist(L[i], i);
        Q.insert({getDist(L[i], i) + getDist(R[i], i) - getDist(L[i], R[i]), i});
    }

    F[N] = ans;

    for(int i=N-1; i>=3; i--)
    {
        auto q = Q.begin();

        ans -= q->first;
        int id = q->second;

        Q.erase(q);

        int idL = L[id];
        int idR = R[id];

        Q.erase({getDist(L[idL], idL) + getDist(R[idL], idL) - getDist(L[idL], R[idL]), idL});
        Q.erase({getDist(L[idR], idR) + getDist(R[idR], idR) - getDist(L[idR], R[idR]), idR});

        L[idR] = idL, R[idL] = idR;

        Q.insert({getDist(L[idL], idL) + getDist(R[idL], idL) - getDist(L[idL], R[idL]), idL});
        Q.insert({getDist(L[idR], idR) + getDist(R[idR], idR) - getDist(L[idR], R[idR]), idR});

        F[i] = ans;
    }

    for(int i=3; i<=N; i++)
        cout << F[i] << " ";

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

long long X[300005], Y[300005];
long long F[300005], memo[300005];

set<int> S;
set< pair<long long, int> > Q;

long long getDist(int x, int y)
{
    return abs(X[x] - X[y]) + abs(Y[x] - Y[y]);
}

int getPrev(int i)
{
    auto it = S.upper_bound(i);

    if(it != S.begin())
    {
        it--;
        return *it;
    }

    it = S.end();
    it--;

    return *it;
}

int getNext(int i)
{
    auto it = S.upper_bound(i);

    if(it != S.end())
        return *it;

    return *S.begin();
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(NULL), cout.tie(NULL);

    int N;
    cin >> N;

    for(int i=1; i<=N; i++)
    {
        S.insert(i);
        cin >> X[i] >> Y[i];
    }

    long long ans = 0;

    for(int i=2; i<=N; i++)
    {
        ans += getDist(i-1, i);
        Q.insert({getDist(i-1, i), i-1});
        memo[i-1] = getDist(i-1, i);
    }

    ans += getDist(1, N);
    Q.insert({getDist(1, N), N});
    memo[N] = getDist(1, N);

    F[N] = ans;

    for(int i=N-1; i>=3; i--)
    {
        auto q = Q.begin();

        ans -= q->first;
        int id = q->second;

        Q.erase(q);
        S.erase(id);

        int idL = getPrev(id);
        int idR = getNext(id);

        Q.erase({memo[idL], idL});
        ans -= memo[idL];

        memo[idL] = getDist(idL, idR);
        Q.insert({memo[idL], idL});
        ans += memo[idL];

        F[i] = ans;
    }

    for(int i=3; i<=N; i++)
        cout << F[i] << " ";

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int MAXN = 3e5 + 5;

int N;
int x[MAXN], y[MAXN];

void load() {
	scanf("%d", &N);
	for (int i = 0; i < N; i++)
		scanf("%d%d", x + i, y + i);
}

inline int nxt(int id) {
	return (id + 1) % N;
}

inline int dist(int p, int q) {
	return abs(x[p] - x[q]) + abs(y[p] - y[q]);
}

void solve() {
	int a = min_element(x, x + N) - x;
	int b = nxt(a);
	int c = nxt(b);
	int sol = 0;
	for (; a < N; a++) {
		for (; nxt(c) != a && dist(b, nxt(c)) + dist(nxt(c), a) > dist(b, c) + dist(c, a); c = nxt(c));
		for (; nxt(b) != c && dist(a, nxt(b)) + dist(nxt(b), c) > dist(a, b) + dist(b, c); b = nxt(b));
		sol = max(sol, dist(a, b) + dist(b, c) + dist(c, a));
	}

	printf("%d", sol);
	int four = 2 * (*max_element(x, x + N) - *min_element(x, x + N) + *max_element(y, y + N) - *min_element(y, y + N));
	for (int i = 4; i <= N; i++)
		printf(" %d", four);
	puts("");
}

int main() {
	load();
	solve();
	return 0;
}


#include <bits/stdc++.h>
using namespace std;

const int MAXN = 3e5 + 5;

int N;
int x[MAXN], y[MAXN];

void load() {
	scanf("%d", &N);
	for (int i = 0; i < N; i++)
		scanf("%d%d", x + i, y + i);
}

inline int nxt(int id) {
	return (id + 1) % N;
}

inline int dist(int p, int q) {
	return abs(x[p] - x[q]) + abs(y[p] - y[q]);
}

void solve() {
	int a = 0, b = 1, c = 2;
	int sol = 0;
	for (; a < N; a++) {
		for (; nxt(c) != a && dist(b, nxt(c)) + dist(nxt(c), a) > dist(b, c) + dist(c, a); c = nxt(c));
		for (; nxt(b) != c && dist(a, nxt(b)) + dist(nxt(b), c) > dist(a, b) + dist(b, c); b = nxt(b));
		sol = max(sol, dist(a, b) + dist(b, c) + dist(c, a));
	}

	printf("%d", sol);
	int four = 2 * (*max_element(x, x + N) - *min_element(x, x + N) + *max_element(y, y + N) - *min_element(y, y + N));
	for (int i = 4; i <= N; i++)
		printf(" %d", four);
	puts("");
}

int main() {
	load();
	solve();
	return 0;
}


using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Linq;
using System.Collections.Generic;

class Solution {
    private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);

    static void Main(string[] args) {
        int n = Next();
        string discard = reader.ReadLine();
        int ret = 0;
        for (int i = 0; i < n; i++) {
            string temp = reader.ReadLine();
            switch (temp)
                {
                    case "Tetrahedron": {ret += 4; break;}
                    case "Cube": {ret += 6; break;}
                    case "Octahedron": {ret += 8; break;}
                    case "Dodecahedron": {ret += 12; break;}
                    case "Icosahedron": {ret += 20; break;}
                    default: {break;}
                }
        }

        Console.WriteLine(ret);
    }

    private static int Next() {
        int c;
        int m = 1;
        do {
            c = reader.Read();
            if (c == '-')
                m = -1;
        } while (c < '0' || c > '9');
        int res = c - '0';
        while (true) {
            c = reader.Read();
            if (c < '0' || c > '9')
                return m*res;
            res *= 10;
            res += c - '0';
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Problem785A
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, int> polyhedrons = new Dictionary<string, int>();
            polyhedrons["Tetrahedron"] = 4;
            polyhedrons["Cube"] = 6;
            polyhedrons["Octahedron"] = 8;
            polyhedrons["Dodecahedron"] = 12;
            polyhedrons["Icosahedron"] = 20;
            int n = int.Parse(Console.ReadLine());
            int sum = 0;
            for (int i = 0; i < n; i++)
            {
                sum += polyhedrons[Console.ReadLine()];
            }
            Console.Write(sum);
            //Console.ReadLine();
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace A.Anton_and_Polyhedrons
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string[] arr = new string[n];
            int sum = 0;
            for(int i=0;i<n;i++)
            {
                arr[i] = Console.ReadLine();
                if(arr[i]=="Tetrahedron")
                {
                    sum += 4;
                }
                else if(arr[i]=="Cube")
                {
                    sum += 6;
                }
                else if(arr[i]=="Octahedron")
                {
                    sum += 8;
                }
                else if(arr[i]=="Dodecahedron")
                {
                    sum += 12;
                }
                else if(arr[i]=="Icosahedron")
                {
                    sum += 20;
                }
            }
            Console.WriteLine(sum);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleTraining
{
  public class Program
  {
    static void Main(string[] args)
    {
      int n = int.Parse(Console.ReadLine());
      List<string> s = new List<string>();
      for(int i = 0; i < n; i++)
        s.Add(Console.ReadLine());
      int br = 0;
      foreach(var d in s)
      {
        switch(d)
        {
          case "Tetrahedron":
          br = br + 4;
          break;
          case "Cube":
          br = br + 6;
          break;
          case "Octahedron":
          br = br + 8;
          break;
          case "Dodecahedron":
          br = br + 12;
          break;
          case "Icosahedron":
          br = br + 20;
          break;

          default:
          br = br + 0;
          break;

        }
      }

      Console.WriteLine(br);
    }
  }
}


using System;

namespace CodeForce
{
    class Program
    {
        static void Main()
        {
            int n = int.Parse(Console.ReadLine()), sum = 0, i = 0;
            for (; i < n; ++i) {
                sum += GetNum(Console.ReadLine());
            }
            Console.WriteLine(sum);
        }

        static int GetNum(string figure)
        {
            var result = 0;
            switch (figure) {
                case "Tetrahedron": result = 4; break;
                case "Cube": result = 6; break;
                case "Octahedron": result = 8; break;
                case "Dodecahedron": result = 12; break;
                case "Icosahedron": result = 20; break;
            }
            return result;
        }
    }
}