#include <bits/stdc++.h>

int dist(int a, int b, int N) {
    if (a <= b) return b - a;
    return N - (a - b);
}

int main() {
    std::cin.tie(NULL);
    std::iostream::sync_with_stdio(false);

    int N;

    std::cin >> N;

    std::vector<int> link(2 * N);

    for (int i = 0; i < N; i++) {
        int x, y;
        std::cin >> x >> y;
        x--;y--;
        link[x] = y;
        link[y] = x;
    }

    std::vector<std::vector<int>> dp(1, std::vector<int>(2 * N, -1));

    std::vector<int> best_ans(2 * N, 1);

    for (int i = 0; i < 2 * N; i++) {
        dp[0][i] = i;
    }

    int res = 0, ans = 1;
    bool compute = true;

    while (compute) {
        dp.push_back(std::vector<int>(2 * N, -1));

        for (int i = 0; i < 2 * N; i++) {
            int j = link[i];
            int x = (i + 1) % (2 * N);
            int y = dp[ans - 1][x];

            if (ans == 1)
                dp[ans][i] = j;
            else if (y != -1 && dist(i, j, 2 * N) == dist(i, x, 2 * N) + dist(x, y, 2 * N) + dist(y, j, 2 * N)) {
                dp[ans][i] = j;
            }
        }

        for (int i = 0; i < 2 * N; i++) {
            bool computable = false;
            while (computable && best_ans[i] < ans) {
                int ansp = best_ans[i];
                int j = dp[ansp][i];

                if (j == -1) {
                    computable = false;
                    break;
                }

                int x = (j + 1) % (2 * N);
                int y = dp[ans - ansp][x];

                if (x != i && y != i && y != -1 && dist(j, i, 2 * N) == dist(j, x, 2 * N) + dist(x, y, 2 * N) + dist(y, i, 2 * N)) {
                    if (dp[ans][i] == -1)
                        dp[ans][i] = y;
                    else if (dist(i, y, 2 * N) <= dist(i, dp[ans][i], 2 * N))
                        dp[ans][i] = y;
                    best_ans[i]++;
                } else
                    computable = false;
            }
        }

        for (int _i = 4 * N - 1; _i >= 0; _i--) {
            int i = _i % (2 * N);
            int inext = (i + 1) % (2 * N);

            if (dp[ans][i] == -1 && dp[ans][inext] != i)
                dp[ans][i] = dp[ans][inext];
            else if (dp[ans][inext] != -1 && dp[ans][inext] != i && dist(i, dp[ans][inext], 2 * N) <= dist(i, dp[ans][i], 2 * N))
                dp[ans][i] = dp[ans][inext];
        }

        //std::cerr << ans << ": \n";

        compute = false;
        for (int i = 0; i < 2 * N; i++)
            if (dp[ans][i] != -1) {
                res = ans;
                compute = true;
                //std::cerr << i + 1 << " -> " << dp[ans][i] + 1 << "\n";
            }
        ans++;
    }

    std::cout << res;

    return 0;
}