Problem: Nauuo is a girl who loves playing chess.

One day she invented a game by herself which needs n chess pieces to play on a m× m chessboard. The rows and columns are numbered from 1 to m. We denote a cell on the intersection of the r-th row and c-th column as (r,c).

The game's goal is to place n chess pieces numbered from 1 to n on the chessboard, the i-th piece lies on (r_i,\,c_i), while the following rule is satisfied: for all pairs of pieces i and j, |r_i-r_j|+|c_i-c_j|≥|i-j|. Here |x| means the absolute value of x.

However, Nauuo discovered that sometimes she couldn't find a solution because the chessboard was too small.

She wants to find the smallest chessboard on which she can put n pieces according to the rules.

She also wonders how to place the pieces on such a chessboard. Can you help her?

Input

The only line contains a single integer n (1≤ n≤ 1000) — the number of chess pieces for the game.

Output

The first line contains a single integer — the minimum value of m, where m is the length of sides of the suitable chessboard.

The i-th of the next n lines contains two integers r_i and c_i (1≤ r_i,c_i≤ m) — the coordinates of the i-th chess piece.

If there are multiple answers, print any.

Examples

Input


2


Output


2
1 1
1 2

Input


4


Output


3
1 1
1 3
3 1
3 3

Note

In the first example, you can't place the two pieces on a 1×1 chessboard without breaking the rule. But you can place two pieces on a 2×2 chessboard like this:

<image>

In the second example, you can't place four pieces on a 2×2 chessboard without breaking the rule. For example, if you place the pieces like this:

<image>

then |r_1-r_3|+|c_1-c_3|=|1-2|+|1-1|=1, |1-3|=2, 1<2; and |r_1-r_4|+|c_1-c_4|=|1-2|+|1-2|=2, |1-4|=3, 2<3. It doesn't satisfy the rule.

However, on a 3×3 chessboard, you can place four pieces like this:

<image>

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class b {
    class Pair implements Comparable<Pair> {
        int a, b;
        Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }
        public int compareTo(Pair o) {
            if (this.a == o.a) {
                return this.b - o.b;
            }
            return this.a - o.a;
        }
    }

    List<Pair> pairs;
    boolean can(int r1, int c1, int r2, int c2, int i, int j, int m) {
        if (i > j) {
            return true;
        }
        if (r1 > m || c1 > m || Math.abs(r1 - r2) + Math.abs(c1 - c2) < Math.abs(i - j)) {
            return false;
        }
        if (i == j) {
            pairs.add(new Pair(r2, c2));
            return true;
        }
        boolean can = true;
        pairs.add(new Pair(r1, c1));
        pairs.add(new Pair(r2, c2));
        if (i % 2 == 0) {
            can &= can(r1 + 1, c1, r2 - 1, c2, i + 1, j - 1, m);
        } else {
            can &= can(r1, c1 + 1, r2, c2 - 1, i + 1, j - 1, m);
        }
        return can;
    }

    private void solve() throws IOException {
        int n = nextInt();
        int ans = 0;
        for (int m = 1; m <= 1000; ++m) {
            pairs = new ArrayList<>();
            if(can(1, 1, m, m, 1, n, m)) {
                ans = m;
                break;
            }
        }
        System.out.println(ans);
        Collections.sort(pairs);
        for (Pair p : pairs) {
            System.out.println(p.a + " " + p.b);
        }
    }

    static void debug(Object...o) {
        System.err.println(Arrays.deepToString(o));
    }

    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;

    String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String s = br.readLine();
            if(s != null) {
                st = new StringTokenizer(s);
            }
        }
        if(st.hasMoreTokens()) {
            return st.nextToken();
        } else {
            return null;
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    String nextLine(){
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }

    private void run() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new b().run();
    }
}