#include <bits/stdc++.h>

template <typename Mono, int TREE_N>
class LinkCutTree {
#define ls son[x][0]
#define rs son[x][1]
    int son[TREE_N][2], fa[TREE_N];
    Mono dp[TREE_N], val[TREE_N];
    bool tag[TREE_N];
    void push_up(int x) {
        dp[x] = dp[ls] * val[x] * dp[rs];
    }
    void push_down(int x) {
        if (tag[x]) {
            tag[ls] ^= 1;
            tag[rs] ^= 1;
            tag[x] = 0;
            std::swap(ls, rs);
        }
    }
    int get(int x) {
        return son[fa[x]][1] == x;
    }
    bool isroot(int x) {
        return son[fa[x]][0] != x && son[fa[x]][1] != x;
    }
    void rotate(int x) {
        int f = fa[x], ff = fa[f], t = get(x);
        fa[x] = ff;
        if (!isroot(f))
            son[ff][get(f)] = x;

        son[f][t] = son[x][t ^ 1], fa[son[x][t ^ 1]] = f;
        push_up(f);

        son[x][t ^ 1] = f, fa[f] = x;
        push_up(x);
    }
    void update(int x) {
        if (!isroot(x))
            update(fa[x]);
        push_down(x);
    }
    void splay(int x) {
        update(x);
        while (!isroot(x)) {
            if (!isroot(fa[x]))
                rotate(get(x) == get(fa[x]) ? fa[x] : x);
            rotate(x);
        }
    }
    void access(int x) {
        for (int p = 0; x; p = x, x = fa[x])
            splay(x), rs = p, push_up(x);
    }
    void make_root(int x) {
        access(x), splay(x), tag[x] ^= 1;
    }

public:
    void link(int x, int y) {
        make_root(x), fa[x] = y;
    }
    void cut(int x, int y) {
        make_root(x), access(y), splay(x);
        if (son[x][1] == y && !son[y][0]) {
            son[x][1] = fa[y] = 0, push_up(x);
        }
    }
    void set(int x, const Mono &v) {
        val[x] = v;
        splay(x);
    }
    Mono query(int u, int v) {
        make_root(u), access(v), splay(v);
        return dp[v];
    }
    int find(int x) {
        access(x), splay(x);
        while (son[x][0]) {
            x = son[x][0];
            push_down(x);
        }
        splay(x);
        return x;
    }
    void clear() {
        for (int i = 0; i < TREE_N; ++i) {
            son[i][0] = son[i][1] = fa[i] = 0;
            dp[i] = val[i] = Mono{};
            tag[i] = false;
        }
    }
#undef ls
#undef rs
};

struct Mono {
    int x;
    friend Mono operator*(const Mono &lhs, const Mono &rhs) {
        return Mono{lhs.x + rhs.x};
    }
};

constexpr int MAXN = 1e5;
LinkCutTree<Mono, MAXN * 4 + 2> lct;

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

    int n;
    std::cin >> n;

    std::vector<std::pair<int, int>> edge(n * 4 + 1);
    for (int i = 1; i <= n; ++i) {
        int u, v;
        std::cin >> u >> v;
        edge[u] = {v, i};
        edge[v] = {u + n * 2, i + n};
    }

    std::vector<int> vals(n * 2 + 1, 1);
    std::vector<int> fa(n * 4 + 2);

    auto iterate = [&]() -> int {
        int res = 0;

        lct.clear();
        std::fill(fa.begin(), fa.end(), 0);

        std::vector<int> nvals = vals;
        for (int rt = n * 4; rt >= 1; --rt) {
            auto [to, id] = edge[rt];

            if (id && rt + 1 < to) {
                nvals[id] = std::max(nvals[id], lct.query(rt + 1, to).x + 1);
            }

            fa[rt + 1] = rt;
            lct.link(fa[rt + 1], rt + 1);

            if (to && lct.query(rt, to + 1).x < vals[id]) {
                lct.cut(fa[to + 1], to + 1);
                fa[to + 1] = rt;
                lct.set(to + 1, Mono{vals[id]});
                lct.link(fa[to + 1], to + 1);
            }

            res =
                std::max(res, lct.query(rt, std::min(rt + n * 2, n * 4 + 1)).x);
        }
        vals = std::move(nvals);

        return res;
    };

    int ans = 0;
    for (int _ = 0; _ < 20; ++_) {
        ans = std::max(ans, iterate());
    }

    // for (int i = 1; i <= n; ++i) {
    //     std::cout << vals[i] << '\n';
    // }
    std::cout << ans << '\n';
}