#include <cstdio>
#include <cassert>

#include <vector>
#include <algorithm>

using namespace std;

vector< pair<int, int> > Queens;
int N;

inline bool ValidArrangement(const vector<int> &primaryDiagonal, const vector<int> &secondaryDiagonal) {
    for (const auto &d: primaryDiagonal)
        if (d > 1)
            return false;
    for (const auto &d: secondaryDiagonal)
        if (d > 1)
            return false;
    return true;
}

inline void UpdateQueen(const int x, const int y, vector<int> &primaryDiagonal, vector<int> &secondaryDiagonal, const int sign) {
    primaryDiagonal[x + y] += sign;
    secondaryDiagonal[N + x - y] += sign;
}

inline void SwapQueens(const int i, const int j, vector<int> &permutation, vector<int> &primaryDiagonal, vector<int> &secondaryDiagonal) {
    UpdateQueen(i, permutation[i], primaryDiagonal, secondaryDiagonal, -1);
    UpdateQueen(j, permutation[j], primaryDiagonal, secondaryDiagonal, -1);
    swap(permutation[i], permutation[j]);
    UpdateQueen(i, permutation[i], primaryDiagonal, secondaryDiagonal, +1);
    UpdateQueen(j, permutation[j], primaryDiagonal, secondaryDiagonal, +1);
}

void Solve() {
    if (2 <= N && N <= 3) {
        Queens.push_back(make_pair(0, 0));
        if (N == 3)
            Queens.push_back(make_pair(1, 2));
        return;
    }
    vector<int> permutation = vector<int>(N), primaryDiagonal, secondaryDiagonal;
    for (int i = 0; i < N; ++i)
        permutation[i] = i;
    do {
        random_shuffle(permutation.begin(), permutation.end());
        primaryDiagonal = secondaryDiagonal = vector<int>(2 * N, 0);
        for (int i = 0; i < N; ++i)
            UpdateQueen(i, permutation[i], primaryDiagonal, secondaryDiagonal, +1);
        for (int i = 0; i < N; ++i) {
            for (int j = i + 1; j < N; ++j) {
                int ii = permutation[i], jj = permutation[j];
                int coefficient = 0;
                coefficient += (primaryDiagonal[i + ii] > 1 ? -1 : 0);
                coefficient += (secondaryDiagonal[N + i - ii] > 1 ? -1 : 0);
                coefficient += (primaryDiagonal[j + jj] > 1 ? -1 : 0);
                coefficient += (secondaryDiagonal[N + j - jj] > 1 ? -1 : 0);
                coefficient += (primaryDiagonal[i + jj] > 0 ? 1 : 0);
                coefficient += (secondaryDiagonal[N - i + jj] > 0 ? 1 : 0);
                coefficient += (primaryDiagonal[j + ii] > 0 ? 1 : 0);
                coefficient += (secondaryDiagonal[N + j - ii] > 0 ? 1 : 0);
                if (coefficient < 0)
                    SwapQueens(i, j, permutation, primaryDiagonal, secondaryDiagonal);
            }
        }
    } while (!ValidArrangement(primaryDiagonal, secondaryDiagonal));
    for (int i = 0; i < N; ++i)
        Queens.push_back(make_pair(i, permutation[i]));
}

void Read() {
    assert(freopen("dame.in", "r", stdin));
    assert(scanf("%d", &N) == 1);
}

void Print() {
    assert(freopen("dame.out", "w", stdout));
    printf("%d\n", int(Queens.size()));
    for (const auto &q: Queens)
        printf("%d %d\n", q.first + 1, q.second + 1);
}

int main() {
    Read();
    Solve();
    Print();
    return 0;
}