#include <algorithm>
#include <cstdint>
#include <iomanip>
#include <ios>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>

namespace segment_tree {

    constexpr std::int32_t log_2(std::int32_t);

    template <typename P>
    std::int32_t for_lvls(std::int32_t node, std::int32_t sz, bool dir, P p) {

        while (node < sz) {
            node = (node << 1 | dir) + (!dir ? p(node) : -p(node));
        }

        return node;

    }

    template <typename F>
    void for_pars(std::int32_t node, bool dir, F f) {

        const std::int32_t lvls = log_2(node);

        for (std::int32_t i = 1; i <= lvls; ++i) {
            f(node >> (!dir ? lvls - i + 1 : i));
        }

    }

    template <typename F>
    void for_rng(std::int32_t node_l, std::int32_t node_r, F f) {

        while (node_l < node_r) {
            if (node_l & 1) {
                f(node_l);
                ++node_l;
            }
            if (node_r & 1) {
                --node_r;
                f(node_r);
            }
            node_l >>= 1;
            node_r >>= 1;
        }

    }

    template <typename F>
    void for_rng_ord(std::int32_t node_l, std::int32_t node_r, bool dir, F f) {

        std::int32_t base = !dir ? node_l - 1 : node_r;
        const std::int32_t mask = (1 << log_2((node_l - 1) ^ node_r)) - 1;
        const std::int32_t shft = !dir ? 1 : -1;

        std::int32_t node = (!dir ? -node_l : node_r) & mask;

        while (node) {
            const std::int32_t bit = __builtin_ctz(node);
            f((base >> bit) + shft);
            node ^= 1 << bit;
        }

        base = dir ? node_l - 1 : node_r;
        node = (dir ? -node_l : node_r) & mask;

        while (node) {
            const std::int32_t bit = log_2(node);
            f((base >> bit) - shft);
            node ^= 1 << bit;
        }

    }

    constexpr std::int32_t log_2(std::int32_t x) {

        return 31 - __builtin_clz(x);

    }

}

template <typename F>
class y_combinator {

private:

    F f;

public:

    explicit y_combinator(F&& f) : f(f) {}

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {

        return f(*this, std::forward<Args>(args)...);

    }

};

template <typename F>
y_combinator(F) -> y_combinator<F>;

void solve() {

    using st_t = std::pair<std::int32_t, double>;

    std::int32_t n;

    std::cin >> n;

    std::vector<std::int32_t> h(n);
    std::vector<std::int32_t> v(n);

    for (std::int32_t i = 0; i < n; ++i) {
        std::cin >> h[i] >> v[i];
    }

    std::vector cmp = h;
    std::vector dp_1(n, st_t(1, 1));
    std::vector dp_2(n, st_t(1, 1));
    const auto merge = [](st_t& base, const st_t& val) -> void {
        if (val.first > base.first) {
            base.first = val.first;
            base.second = 0;
        }
        if (val.first == base.first) {
            base.second += val.second;
        }
    };
    st_t tot_st;

    cmp.insert(std::end(cmp), std::begin(v), std::end(v));

    std::sort(std::begin(cmp), std::end(cmp));

    cmp.erase(std::unique(std::begin(cmp), std::end(cmp)), std::end(cmp));

    for (auto& x : h) {
        x = std::lower_bound(std::begin(cmp), std::end(cmp), x) - std::begin(cmp);
    }

    for (auto& x : v) {
        x = std::lower_bound(std::begin(cmp), std::end(cmp), x) - std::begin(cmp);
    }

    const std::int32_t sz = std::size(cmp);

    const std::int32_t seg_sz = 1 << segment_tree::log_2(sz * 2 - 1);

    std::vector<st_t> sts(seg_sz * 2);

    const auto pull = [&](std::int32_t node) -> void {
        sts[node] = st_t();
        merge(sts[node], sts[node << 1]);
        merge(sts[node], sts[node << 1 | 1]);
    };

    y_combinator(
        [&](auto self, std::int32_t idx_l, std::int32_t idx_r) -> void {
            const auto cmp = [&](std::int32_t idx_1, std::int32_t idx_2) -> bool {
                return h[idx_1] > h[idx_2];
            };
            const std::int32_t idx_m = (idx_l + idx_r) / 2;
            std::int32_t ptr = 0;
            if (idx_m - idx_l > 1) {
                self(idx_l, idx_m);
            }
            std::vector<std::int32_t> ord_l(idx_m - idx_l);
            std::vector<std::int32_t> ord_r(idx_r - idx_m);
            std::iota(std::begin(ord_l), std::end(ord_l), idx_l);
            std::iota(std::begin(ord_r), std::end(ord_r), idx_m);
            std::sort(std::begin(ord_l), std::end(ord_l), cmp);
            std::sort(std::begin(ord_r), std::end(ord_r), cmp);
            for (auto x : ord_r) {
                while (ptr < idx_m - idx_l && h[ord_l[ptr]] >= h[x]) {
                    merge(sts[seg_sz + v[ord_l[ptr]]], dp_1[ord_l[ptr]]);
                    segment_tree::for_pars(seg_sz + v[ord_l[ptr]], true, pull);
                    ++ptr;
                }
                segment_tree::for_rng(
                    seg_sz + v[x], seg_sz + sz,
                    [&](std::int32_t node) -> void {
                        const auto& [mx, cnt] = sts[node];
                        merge(dp_1[x], st_t(mx + 1, cnt));
                    }
                );
            }
            for (std::int32_t i = 0; i < ptr; ++i) {
                sts[seg_sz + v[ord_l[i]]] = st_t();
                segment_tree::for_pars(seg_sz + v[ord_l[i]], true, pull);
            }
            if (idx_r - idx_m > 1) {
                self(idx_m, idx_r);
            }
        }
    )(0, n);

    y_combinator(
        [&](auto self, std::int32_t idx_l, std::int32_t idx_r) -> void {
            const auto cmp = [&](std::int32_t idx_1, std::int32_t idx_2) -> bool {
                return h[idx_1] < h[idx_2];
            };
            const std::int32_t idx_m = (idx_l + idx_r) / 2;
            std::int32_t ptr = 0;
            if (idx_r - idx_m > 1) {
                self(idx_m, idx_r);
            }
            std::vector<std::int32_t> ord_l(idx_m - idx_l);
            std::vector<std::int32_t> ord_r(idx_r - idx_m);
            std::iota(std::begin(ord_l), std::end(ord_l), idx_l);
            std::iota(std::begin(ord_r), std::end(ord_r), idx_m);
            std::sort(std::begin(ord_l), std::end(ord_l), cmp);
            std::sort(std::begin(ord_r), std::end(ord_r), cmp);
            for (auto x : ord_l) {
                while (ptr < idx_r - idx_m && h[ord_r[ptr]] <= h[x]) {
                    merge(sts[seg_sz + v[ord_r[ptr]]], dp_2[ord_r[ptr]]);
                    segment_tree::for_pars(seg_sz + v[ord_r[ptr]], true, pull);
                    ++ptr;
                }
                segment_tree::for_rng(
                    seg_sz, seg_sz + v[x] + 1,
                    [&](std::int32_t node) -> void {
                        const auto& [mx, cnt] = sts[node];
                        merge(dp_2[x], st_t(mx + 1, cnt));
                    }
                );
            }
            for (std::int32_t i = 0; i < ptr; ++i) {
                sts[seg_sz + v[ord_r[i]]] = st_t();
                segment_tree::for_pars(seg_sz + v[ord_r[i]], true, pull);
            }
            if (idx_m - idx_l > 1) {
                self(idx_l, idx_m);
            }
        }
    )(0, n);

    for (const auto& x : dp_1) {
        merge(tot_st, x);
    }

    std::cout << tot_st.first << '\n';

    for (std::int32_t i = 0; i < n; ++i) {
        const auto& [mx_1, cnt_1] = dp_1[i];
        const auto& [mx_2, cnt_2] = dp_2[i];
        std::cout << (mx_1 + mx_2 - 1 == tot_st.first ? cnt_1 * cnt_2 / tot_st.second : 0);
        std::cout << (i < n - 1 ? ' ' : '\n');
    }

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    std::cout << std::fixed << std::setprecision(8);

    solve();

    return 0;

}