//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx")
//#undef LOCAL




#include <algorithm>

#include <array>

#include <bitset>

#include <cassert>

#include <complex>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <vector>

using namespace std;

using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;



#include <unistd.h>

struct Scanner {
    int fd = -1;
    char line[(1 << 15) + 1];
    size_t st = 0, ed = 0;
    void reread() {
        memmove(line, line + st, ed - st);
        ed -= st;
        st = 0;
        ed += ::read(fd, line + ed, (1 << 15) - ed);
        line[ed] = '\0';
    }
    bool succ() {
        while (true) {
            if (st == ed) {
                reread();
                if (st == ed) return false;
            }
            while (st != ed && isspace(line[st])) st++;
            if (st != ed) break;
        }
        if (ed - st <= 50) {
            bool sep = false;
            for (size_t i = st; i < ed; i++) {
                if (isspace(line[i])) {
                    sep = true;
                    break;
                }
            }
            if (!sep) reread();
        }
        return true;
    }
    template <class T, enable_if_t<is_same<T, string>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        while (true) {
            size_t sz = 0;
            while (st + sz < ed && !isspace(line[st + sz])) sz++;
            ref.append(line + st, sz);
            st += sz;
            if (!sz || st != ed) break;
            reread();
        }
        return true;
    }
    template <class T, enable_if_t<is_integral<T>::value>* = nullptr>
    bool read_single(T& ref) {
        if (!succ()) return false;
        bool neg = false;
        if (line[st] == '-') {
            neg = true;
            st++;
        }
        ref = T(0);
        while (isdigit(line[st])) {
            ref = 10 * ref + (line[st++] & 0xf);
        }
        if (neg) ref = -ref;
        return true;
    }
    template <class T> bool read_single(V<T>& ref) {
        for (auto& d : ref) {
            if (!read_single(d)) return false;
        }
        return true;
    }
    void read() {}
    template <class H, class... T> void read(H& h, T&... t) {
        bool f = read_single(h);
        assert(f);
        read(t...);
    }
    int read_unsafe() { return 0; }
    template <class H, class... T> int read_unsafe(H& h, T&... t) {
        bool f = read_single(h);
        if (!f) return 0;
        return 1 + read_unsafe(t...);
    }
    Scanner(FILE* fp) : fd(fileno(fp)) {}
};

struct Printer {
  public:
    template <bool F = false> void write() {}
    template <bool F = false, class H, class... T>
    void write(const H& h, const T&... t) {
        if (F) write_single(' ');
        write_single(h);
        write<true>(t...);
    }
    template <class... T> void writeln(const T&... t) {
        write(t...);
        write_single('\n');
    }

    Printer(FILE* _fp) : fp(_fp) {}
    ~Printer() { flush(); }

  private:
    static constexpr size_t SIZE = 1 << 15;
    FILE* fp;
    char line[SIZE], small[50];
    size_t pos = 0;
    void flush() {
        fwrite(line, 1, pos, fp);
        pos = 0;
    }
    void write_single(const char& val) {
        if (pos == SIZE) flush();
        line[pos++] = val;
    }
    template <class T, enable_if_t<is_integral<T>::value>* = nullptr>
    void write_single(T val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val; // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char(0x30 | (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }
    void write_single(__int128 val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val; // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char(0x30 | (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }

    void write_single(const string& s) {
        for (char c : s) write_single(c);
    }
    void write_single(const char* s) {
        size_t len = strlen(s);
        for (size_t i = 0; i < len; i++) write_single(s[i]);
    }
    template <class T> void write_single(const V<T>& val) {
        auto n = val.size();
        for (size_t i = 0; i < n; i++) {
            if (i) write_single(' ');
            write_single(val[i]);
        }
    }
};
struct UnionFind {
    int n;
    V<int> p, r;
    int gn;
    UnionFind(int _n = 0) : n(_n), p(n, -1), r(n, 1), gn(n) {}
    void merge(int a, int b) {
        assert(0 <= a && a < n);
        assert(0 <= b && b < n);
        int x = group(a), y = group(b);
        if (x == y) return; // same
        gn--;
        if (r[x] < r[y]) swap(x, y);
        p[y] = x;
        r[x] += r[y];
    }
    int group(int a) {
        assert(0 <= a && a < n);
        if (p[a] == -1) return a;
        return p[a] = group(p[a]);
    }
    bool same(int a, int b) {
        assert(0 <= a && a < n);
        assert(0 <= b && b < n);
        return group(a) == group(b);
    }
};

Scanner sc = Scanner(stdin);
Printer pr = Printer(stdout);

ll pdist(ll xa, ll ya, ll xb, ll yb) {
    return abs(xa - xb) + abs(ya - yb);
}

V<ll> solve(V<int> ys, V<ll> xv, V<ll> yv) {
    int n = int(ys.size());
    V<ll> dist(n - 1);
    V<ll> dsm(n);
    for (int i = 0; i < n - 1; i++) {
        dist[i] = pdist(xv[i], yv[i], xv[i + 1], yv[i + 1]);
        dsm[i + 1] = dsm[i] + dist[i];
    }
             ;


    auto uf = UnionFind(n);
    for (int i = 0; i < n - 1; i++) {
        if (abs(ys[i] - ys[i + 1]) == 1) {
            uf.merge(i, i + 1);
        }
    }
    int m = uf.gn;
    using P = pair<int, int>;
    V<P> rngs(m);
    V<int> ymins(m), ymaxs(m);
    {
        int l = 0;
        for (int i = 0; i < m; i++) {
            int r = l;
            while (r < n && uf.same(l, r)) r++;
            r--;
            rngs[i] = {l, r};
            ymins[i] = TEN(9);
            ymaxs[i] = -TEN(9);
            for (int j = l; j <= r; j++) {
                ymins[i] = min(ymins[i], ys[j]);
                ymaxs[i] = max(ymaxs[i], ys[j]);
            }
            l = r + 1;
        }
    }
             ;
    using Key = tuple<int, int, int>;
    map<Key, ll> dp;
    auto dfs = [&](auto self, int lid, int rid, int ymin, int ymax, int pos) {
        bool lok = false, rok = false;
        {
            int l = rngs[lid].first;
            if (l) {
                int z = ys[l - 1];
                if (z == ymin - 1 || z == ymax + 1) {
                    lok = true;
                }
            }
        }
        {
            int r = rngs[rid].second;
            if (r + 1 < n) {
                int z = ys[r + 1];
                if (z == ymin - 1 || z == ymax + 1) {
                    rok = true;
                }
            }
        }
        if (!lok && !rok) return - ll(rngs[rid].second - rngs[lid].first);

        Key key = {lid, rid, pos};
        if (dp.count(key)) return dp[key];

        ll ans = TEN(18);
        if (lok) {
            int mpos = rngs[lid - 1].second;
            int npos = rngs[lid - 1].first;
            ll di = pdist(xv[pos], yv[pos], xv[mpos], yv[mpos]) + dsm[mpos] - dsm[npos];
            ans = min(ans, di + self(self, lid - 1, rid, min(ymin, ymins[lid - 1]), max(ymax, ymaxs[lid - 1]), npos));
        }
        if (rok) {
            int mpos = rngs[rid + 1].first;
            int npos = rngs[rid + 1].second;
            ll di = pdist(xv[pos], yv[pos], xv[mpos], yv[mpos]) + dsm[npos] - dsm[mpos];
            ans = min(ans, di + self(self, lid, rid + 1, min(ymin, ymins[rid + 1]), max(ymax, ymaxs[rid + 1]), npos));
        }
        return dp[key] = ans;
    };

    V<ll> ans(n, TEN(18));
    for (int i = 0; i < m; i++) {
        auto rng = rngs[i];
        int l = rng.first, r = rng.second;
        for (int j = l; j <= r; j++) {
            {
                ll di = dsm[r] - dsm[j] + dsm[r] - dsm[l];
                          ;
                ans[j] = min(ans[j], di + dfs(dfs, i, i, ymins[i], ymaxs[i], l));
            }
            {
                ll di = dsm[j] - dsm[l] + dsm[r] - dsm[l];
                          ;
                ans[j] = min(ans[j], di + dfs(dfs, i, i, ymins[i], ymaxs[i], r));
            }
        }
    }
    return ans;
}

int main() {
    int n;
    sc.read(n);

    V<ll> x(n), y(n);
    for (int i = 0; i < n; i++) {
        sc.read(x[i], y[i]);
    }

    V<int> xidx(n), yidx(n);
    iota(xidx.begin(), xidx.end(), 0);
    iota(yidx.begin(), yidx.end(), 0);
    sort(xidx.begin(), xidx.end(), [&](int a, int b) { return x[a] < x[b]; });
    sort(yidx.begin(), yidx.end(), [&](int a, int b) { return y[a] < y[b]; });

                   ;

    V<int> rxi(n), ryi(n);
    for (int i = 0; i < n; i++) {
        rxi[xidx[i]] = i;
        ryi[yidx[i]] = i;
    }

    V<int> ys(n);
    V<ll> xv(n), yv(n);
    for (int i = 0; i < n; i++) {
        int p = xidx[i];
        ys[i] = ryi[p];
        xv[i] = x[p];
        yv[i] = y[p];
    }

    auto ans = solve(ys, xv, yv);
                        ;

    for (int i = 0; i < n; i++) {
        pr.writeln(ans[rxi[i]]);
    }
    return 0;
}


Measured memory_bytes: 71244