import java.util.*;
import java.io.*;
public class C1368 {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static StringTokenizer st;
	public static void main(String[]args)throws IOException {
		int n = readInt();
		/*
		 0000000000
		 0000000000
		 0000000000
		 0000000000
		 0000022200
		 0220020200
		 222222020
		 0220020200
		 0000022200

		 */

		for(int i = 0; i<n; i++) {
			//x = 2 and 4
			int t = n/4;
			int rem = n%4;
			int total = 20000;
			total+=t*12;
			total+=3*rem;
			total+=2;
			pr.println(total);
			for(int j = 1; j<=10000; j++) {
				pr.println(2+ " " + j); pr.println(4+" " + j);
			}
			pr.println("3 1"); pr.println("3 10000");

			for(int j = 1; j<=t; j++) {
				int num = 10*j;
				pr.println(3+" " + num);
				pr.println(1+" " + num);
				pr.println(5+" " + num);
				pr.println(0+" " + num);
				pr.println(6+" " + num);
				pr.println(6+" " + (num+1));
				pr.println(6+" " + (num+2));
				pr.println(0+" " + (num+1));
				pr.println(0+" " + (num+2));
				pr.println(1+" " + (num+2));
				pr.println(3+" " + (num+2));
				pr.println(5+" " + (num+2));

			}
			if(rem==1) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
			}
			else if(rem==2) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
			}
			else if(rem==3) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
				pr.println("2 10001");pr.println("1 10001");pr.println("1 10000");
			}
		}
		pr.close();
	}
	static String next () throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}
	static long readLong () throws IOException {
		return Long.parseLong(next());
	}
	static int readInt () throws IOException {
		return Integer.parseInt(next());
	}
	static double readDouble () throws IOException {
		return Double.parseDouble(next());
	}
	static char readChar () throws IOException {
		return next().charAt(0);
	}
	static String readLine () throws IOException {
		return br.readLine().trim();
	}
}


import java.util.*;
import java.io.*;
public class C1368 {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static StringTokenizer st;
	public static void main(String[]args)throws IOException {
		int n = readInt();
		/*
		 *
		 * 220
		 * 222
		 * 022
		 *
		 *
		 */
		pr.println(7*n);
		for(int i = 0; i<n; i++) {
			int start = i*5;
			pr.println(start+ " " +1);
			pr.println(start+ " " +2);
			pr.println((start+1)+ " " +0);
			pr.println((start+1)+ " " +1);
			pr.println((start+1)+ " " +2);
			pr.println((start+2)+ " " +0);
			pr.println((start+2)+ " " +1);
		}
		pr.close();
	}
	static String next () throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}
	static long readLong () throws IOException {
		return Long.parseLong(next());
	}
	static int readInt () throws IOException {
		return Integer.parseInt(next());
	}
	static double readDouble () throws IOException {
		return Double.parseDouble(next());
	}
	static char readChar () throws IOException {
		return next().charAt(0);
	}
	static String readLine () throws IOException {
		return br.readLine().trim();
	}
}


import java.util.*;
import java.io.*;
public class C1368 {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static StringTokenizer st;
	public static void main(String[]args)throws IOException {
		int n = readInt();
		/*
		 0000000000
		 0000000000
		 0000000000
		 0000000000
		 0000022200
		 0220020200
		 222222020
		 0220020200
		 0000022200

		 */

		for(int i = 0; i<n; i++) {
			//x = 2 and 4
			int t = n/4;
			int rem = n%4;
			int total = 20000;
			total+=t*12;
			total+=3*rem;
			pr.println(total);
			for(int j = 1; j<=10000; j++) {
				pr.println(2+ " " + j); pr.println(4+" " + j);
			}
			pr.println("3 1"); pr.println("3 10000");

			for(int j = 1; j<=t; j++) {
				int num = 10*j;
				pr.println(3+" " + num);
				pr.println(1+" " + num);
				pr.println(5+" " + num);
				pr.println(0+" " + num);
				pr.println(6+" " + num);
				pr.println(6+" " + (num+1));
				pr.println(6+" " + (num+2));
				pr.println(0+" " + (num+1));
				pr.println(0+" " + (num+2));
				pr.println(1+" " + (num+2));
				pr.println(3+" " + (num+2));
				pr.println(5+" " + (num+2));

			}
			if(rem==1) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
			}
			else if(rem==2) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
			}
			else if(rem==3) {
				pr.println("2 0");pr.println("1 0");pr.println("2 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
				pr.println("2 10001");pr.println("1 10001");pr.println("1 10000");
			}
		}
		pr.close();
	}
	static String next () throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}
	static long readLong () throws IOException {
		return Long.parseLong(next());
	}
	static int readInt () throws IOException {
		return Integer.parseInt(next());
	}
	static double readDouble () throws IOException {
		return Double.parseDouble(next());
	}
	static char readChar () throws IOException {
		return next().charAt(0);
	}
	static String readLine () throws IOException {
		return br.readLine().trim();
	}
}


import java.util.*;
import java.io.*;
public class C1368 {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static StringTokenizer st;
	public static void main(String[]args)throws IOException {
		int n = readInt();
		/*
		 0000000000
		 0000000000
		 0000000000
		 0000000000
		 0000022200
		 0220020200
		 222222020
		 0220020200
		 0000022200

		 */

		for(int i = 0; i<n; i++) {
			//x = 2 and 4
			int t = n/4;
			int rem = n%4;
			int total = 20000;
			total+=t*12;
			total+=3*rem;
			total+=2;
			pr.println(total);
			for(int j = 1; j<=10000; j++) {
				pr.println(2+ " " + j); pr.println(4+" " + j);
			}
			pr.println("3 1"); pr.println("3 10000");

			for(int j = 1; j<=t; j++) {
				int num = 10*j;
				pr.println(3+" " + num);
				pr.println(1+" " + num);
				pr.println(5+" " + num);
				pr.println(0+" " + num);
				pr.println(6+" " + num);
				pr.println(6+" " + (num+1));
				pr.println(6+" " + (num+2));
				pr.println(0+" " + (num+1));
				pr.println(0+" " + (num+2));
				pr.println(1+" " + (num+2));
				pr.println(3+" " + (num+2));
				pr.println(5+" " + (num+2));

			}
			if(rem==1) {
				pr.println("2 0");pr.println("1 0");pr.println("1 1");
			}
			else if(rem==2) {
				pr.println("2 0");pr.println("1 0");pr.println("1 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
			}
			else if(rem==3) {
				pr.println("2 0");pr.println("1 0");pr.println("1 1");
				pr.println("4 0");pr.println("5 0");pr.println("5 1");
				pr.println("2 10001");pr.println("1 10001");pr.println("1 10000");
			}
		}
		pr.close();
	}
	static String next () throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}
	static long readLong () throws IOException {
		return Long.parseLong(next());
	}
	static int readInt () throws IOException {
		return Integer.parseInt(next());
	}
	static double readDouble () throws IOException {
		return Double.parseDouble(next());
	}
	static char readChar () throws IOException {
		return next().charAt(0);
	}
	static String readLine () throws IOException {
		return br.readLine().trim();
	}
}


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        boolean vis[][] = new boolean[n+10][n+10];
        for (int i = 0 ; i < n ; i++){
            vis[i][i] = true;
            vis[i+1][i] = true;
            vis[i][i+1] = true;
        }
        vis[n][n] = true;
        int cnt = 0;
        for (int i = 0 ; i < n+10 ; i++){
            for (int  j = 0 ; j < n+10 ; j++){
                if (vis[i][j]){
                    cnt++;
                }
            }
        }
        out.println(cnt);
        for (int i = 0 ; i < n+10 ; i++){
            for (int j = 0 ; j < n+10 ; j++){
                if (vis[i][j]){
                    out.println(i+" "+j);
                }
            }
        }

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        int cnt = 3*n + 8 + 4 + n;
        out.println(cnt);
        int x = 10;
        int y = 10;
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+1));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y-1));
        }
        out.println((x-1)+" "+y);
        out.println((x-2)+" "+y);
        out.println((x-2)+" "+(y+1));
        out.println((x-2)+" "+(y+2));
        out.println((x-2)+" "+(y+3));
        out.println((x-1)+" "+(y+3));
        out.println((x+n)+" "+y);
        out.println((x+n+1)+" "+y);
        out.println((x+n+1)+" "+(y+1));
        out.println((x+n+1)+" "+(y+2));
        out.println((x+n+1)+" "+(y+3));
        out.println((x+n)+" "+(y+3));
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+3));
        }

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        boolean vis[][] = new boolean[n+10][n+10];
        for (int i = 0 ; i <= n ; i++){
            vis[i][i] = true;
            vis[i+1][i] = true;
            vis[i][i+1] = true;
        }
        vis[n+1][n+1] = true;
        int cnt = 0;
        for (int i = 0 ; i < n+10 ; i++){
            for (int  j = 0 ; j < n+10 ; j++){
                if (vis[i][j]){
                    cnt++;
                }
            }
        }
        out.println(cnt);
        for (int i = 0 ; i < n+10 ; i++){
            for (int j = 0 ; j < n+10 ; j++){
                if (vis[i][j]){
                    out.println(i+" "+j);
                }
            }
        }

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        int cnt = 3*n + 8 + 4 + n;
        out.println(cnt);
        int x = 10;
        int y = 10;
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+1));
            out.println((x+i)+" "+(y-1));
        }
        for (int i =-2 ; i < n+2 ; i++){
            out.println((x+i)+" "+(y));
            out.println((x+i)+" "+(y+3));
        }
        out.println((x-2)+" "+(y+1));
        out.println((x-2)+" "+(y+2));
        out.println((x+n+1)+" "+(y+1));
        out.println((x+n+1)+" "+(y+2));

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        int cnt = 3*n + 8 + 4 + n;
        System.out.println(cnt);
        int x = 10;
        int y = 10;
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i+1));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i-1));
        }
        out.println((x-1)+" "+y);
        out.println((x-2)+" "+y);
        out.println((x-2)+" "+(y+1));
        out.println((x-2)+" "+(y+2));
        out.println((x-2)+" "+(y+3));
        out.println((x-1)+" "+(y+3));
        out.println((x+n)+" "+y);
        out.println((x+n+1)+" "+y);
        out.println((x+n+1)+" "+(y+1));
        out.println((x+n+1)+" "+(y+2));
        out.println((x+n+1)+" "+(y+3));
        out.println((x+n)+" "+(y+3));
        for (int i = 0 ; i < n ; i++){
            out.println(x+" "+(y+3));
        }

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import javax.print.DocFlavor;
import javax.print.attribute.standard.RequestingUserName;
import java.io.*;
import java.lang.reflect.Array;
import java.net.Inet4Address;
import java.nio.charset.IllegalCharsetNameException;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class Solution {
    public static void main(String[] args) throws IOException{
        Reader.init(System.in);
        long h = 973303; long c  = 519683 ; long t = 866255;
        double lol = (double)(h-t) /(double) (2*t - h - c);
        for (int i = 0 ; i < 15 ; i++){
//            System.out.println(i +" " + ((i+10)%15));
        }
//        System.out.println(lol);
//        t =Reader.nextInt();
        t =1;
//        System.out.println(cnt);
        PrintWriter out = new PrintWriter(System.out);
        int i = 1;
        while (t-->0){
//            out.print("Case #" + i + ": ");
            solve(out);
            i++;
        }
        out.close();
    }
    static class Pair{
        int l , r;

        public Pair(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }
    static int[][] arr;
    static int n;
    static int m;
    static int[][] dep1;
    static int[][] dep2;
    static boolean[][] v1;
    static boolean[][] v2;
    static TreeSet<Integer> set = new TreeSet<>();
    static void solve(PrintWriter out)throws IOException {
        int n = Reader.nextInt();
        int cnt = 3*n + 8 + 4 + n;
        out.println(cnt);
        int x = 10;
        int y = 10;
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i+1));
        }
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+i-1));
        }
        out.println((x-1)+" "+y);
        out.println((x-2)+" "+y);
        out.println((x-2)+" "+(y+1));
        out.println((x-2)+" "+(y+2));
        out.println((x-2)+" "+(y+3));
        out.println((x-1)+" "+(y+3));
        out.println((x+n)+" "+y);
        out.println((x+n+1)+" "+y);
        out.println((x+n+1)+" "+(y+1));
        out.println((x+n+1)+" "+(y+2));
        out.println((x+n+1)+" "+(y+3));
        out.println((x+n)+" "+(y+3));
        for (int i = 0 ; i < n ; i++){
            out.println((x+i)+" "+(y+3));
        }

    }
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        boolean prime[] = new boolean[n+1];
        for(int i=0;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == true)
            {
                // Update all multiples of p
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for(int i = 2; i <= n; i++)
        {
            if(prime[i] == true){
                set.add(i);
            }
        }
    }

    static void dfs1(int i , int j, int d){
        if (check(i,j)){
            if (v1[i][j]){
                return;
            }
            v1[i][j] = true;
//            System.out.println(i+" " + j + " " + d);
            dep1[d][arr[i][j]]++;
            dfs1(i+1,j,d+1);
            dfs1(i,j+1 , d+1);
        }
        else{
            return;
        }
    }
    static void dfs2(int i , int j, int d){
        if (check(i,j)){
            if (v2[i][j]){
                return;
            }
            v2[i][j] = true;
            dep1[d][arr[i][j]]++;
            dfs2(i-1,j,d+1);
            dfs2(i,j-1 , d+1);
        }
        else{
            return;
        }
    }
    static boolean check(int i , int j ){
        if (i<0 || j <0 || i>= n || j>=m){
            return false;
        }
        return true;
    }

    public static int stringCompare(String str1, String str2)
    {

        int l1 = str1.length();
        int l2 = str2.length();
        int lmin = Math.min(l1, l2);

        for (int i = 0; i < lmin; i++) {
            int str1_ch = (int)str1.charAt(i);
            int str2_ch = (int)str2.charAt(i);

            if (str1_ch != str2_ch) {
                return str1_ch - str2_ch;
            }
        }

        // Edge case for strings like
        // String 1="Geeks" and String 2="Geeksforgeeks"
        if (l1 != l2) {
            return l1 - l2;
        }

        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

    static int next(long[] arr, long target)
    {
        int start = 0, end = arr.length - 1;

        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;

            // Move to right side if target is
            // greater.
            if (arr[mid] <= target) {
                start = mid + 1;
            }

            // Move left side.
            else {
                ans = mid;
                end = mid - 1;
            }
        }
        return ans;
    }

//    static int find(int x) {
//        return parent[x] == x ? x : (parent[x] = find(parent[x]));
//    }
//    static boolean merge(int x, int y) {
//        x = find(x);
//        y = find(y);
//        if (x==y){
//            return false;
//        }
//        parent[x] = y;
//        return true;
//    }

    public static void sortbyColumn(int arr[][], int col)
    {
        // Using built-in sort function Arrays.sort
        Arrays.sort(arr, new Comparator<int[]>() {

            @Override
            // Compare values according to columns
            public int compare(final int[] entry1,
                               final int[] entry2) {

                // To sort in descending order revert
                // the '>' Operator
                if (entry1[col] > entry2[col])
                    return 1;
                else
                    return -1;
            }
        });  // End of function call sort().
    }

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}
class Pair{
    int a;
    int b;

    public Pair(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class MergeSort
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]

    void merge(int arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int [n1];
        int R[] = new int [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    /* A utility function to print array of size n */
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i<n; ++i)
            System.out.print(arr[i] + " ");
        System.out.println();
    }

    // Driver method

}

class Node implements Comparable<Node>{
    int a;
    int b;
    Node (int a , int b){
        this.a = a;
        this.b = b;
    }

    public int compareTo(Node o) {
        if ((this.a%2) == (o.a%2)){
            return (this.b - o.b);
        }
        else{
            return this.a - o.a;
        }
    }
}
class Graph
{
    int V;// No. of vertices

    //An Array of List which contains
    //references to the Adjacency List of
    //each vertex
    List <Integer> adj[];
    public Graph(int V)// Constructor
    {
        this.V = V;
        adj = new ArrayList[V];
        for(int i = 0; i < V; i++)
            adj[i]=new ArrayList<Integer>();
    }

    // function to add an edge to graph
    public void addEdge(int u,int v)
    {
        adj[u].add(v);
    }
    // prints a Topological Sort of the complete graph
    public void topologicalSort(PrintWriter out,TreeSet set)
    {
        // Create a array to store indegrees of all
        // vertices. Initialize all indegrees as 0.
        int indegree[] = new int[V];

        // Traverse adjacency lists to fill indegrees of
        // vertices. This step takes O(V+E) time
        for(int i = 0; i < V; i++)
        {
            ArrayList<Integer> temp = (ArrayList<Integer>) adj[i];
            for(int node : temp)
            {
                indegree[node]++;
            }
        }

        // Create a queue and enqueue all vertices with
        // indegree 0
        Queue<Integer> q = new LinkedList<Integer>();
        for(int i = 0;i < V; i++)
        {
            if(indegree[i]==0)
                q.add(i);
        }

        // Initialize count of visited vertices
        int cnt = 0;

        // Create a vector to store result (A topological
        // ordering of the vertices)
        Vector <Integer> topOrder=new Vector<Integer>();
        while(!q.isEmpty())
        {
            // Extract front of queue (or perform dequeue)
            // and add it to topological order
            int u=q.poll();
            topOrder.add(u);

            // Iterate through all its neighbouring nodes
            // of dequeued node u and decrease their in-degree
            // by 1
            for(int node : adj[u])
            {
                // If in-degree becomes zero, add it to queue
                if(--indegree[node] == 0)
                    q.add(node);
            }
            cnt++;
        }

        // Check if there was a cycle
        if(cnt != V)
        {
            out.println(-1);
            return ;
        }

        // Print topological order
        for(int i : topOrder)
        {
            if (set.contains((char)('A'+i))) {
                out.print((char) ('A' + i));
            }
        }
        out.println();
    }
}
// Driver program to test above functions


import java.util.*;
import java.io.*;

public class C_1368 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int ct = 0;
		ArrayList<Pair> list = new ArrayList<>();

		for(int i = 0; i < 2 * n + 1; i++) {
			list.add(new Pair(5, 5 + i));
			ct++;
		}

		if(n % 2 == 0) {
			for(int j = 6; j < 5 + 2 * n + 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 5 + 2 * n + 1;
			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 4;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;

		} else {
			for(int j = 6; j < 5 + 2 * n - 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 4 + 2 * n;
			list.add(new Pair(4, j));
			list.add(new Pair(3, j));
			list.add(new Pair(3, j + 1));
			list.add(new Pair(3, j + 2));
			list.add(new Pair(4, j + 2));
			list.add(new Pair(5, j + 2));
			ct += 6;

			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 4;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;
		}

		pw.println(ct);
		for(Pair p : list)
			pw.println(p);
		pw.flush();
	}

	public static class Pair {
		int i, j;

		public Pair(int i, int j) {
			this.i = i;
			this.j = j;
		}

		public String toString() {
			return i + " " + j;
		}
	}

	public static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


import java.util.*;
import java.io.*;

public class C_1368 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int ct = 0;
		ArrayList<Pair> list = new ArrayList<>();

		for(int i = 0; i < 2 * n + 1; i++) {
			list.add(new Pair(5, 5 + i));
			ct++;
		}

		if(n % 2 == 0) {
			for(int j = 6; j < 5 + 2 * n + 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 5 + 2 * n + 1;
			list.add(new Pair(5, j));
			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 5;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;

		} else {
			for(int j = 6; j < 5 + 2 * n - 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 4 + 2 * n;
			list.add(new Pair(4, j));
			list.add(new Pair(3, j));
			list.add(new Pair(3, j + 1));
			list.add(new Pair(3, j + 2));
			list.add(new Pair(4, j + 2));
			list.add(new Pair(5, j + 2));
			ct += 6;

			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 4;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;
		}

		pw.println(list.size());
		for(Pair p : list)
			pw.println(p);
		pw.flush();
	}

	public static class Pair {
		int i, j;

		public Pair(int i, int j) {
			this.i = i;
			this.j = j;
		}

		public String toString() {
			return j + " " + i;
		}
	}

	public static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


import java.util.*;
import java.io.*;

public class C_1368 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int ct = 0;
		ArrayList<Pair> list = new ArrayList<>();

		for(int i = 0; i < 2 * n + 1; i++) {
			list.add(new Pair(5, 5 + i));
			ct++;
		}

		if(n % 2 == 0) {
			for(int j = 6; j < 5 + 2 * n + 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 5 + 2 * n + 1;
			list.add(new Pair(5, j));
			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 4;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;

		} else {
			for(int j = 6; j < 5 + 2 * n - 1; j += 4) {
				list.add(new Pair(4, j));
				list.add(new Pair(3, j));
				list.add(new Pair(3, j + 1));
				list.add(new Pair(3, j + 2));
				list.add(new Pair(4, j + 2));
				ct += 5;

				list.add(new Pair(6, j));
				list.add(new Pair(7, j));
				list.add(new Pair(7, j + 1));
				list.add(new Pair(7, j + 2));
				list.add(new Pair(6, j + 2));
				ct += 5;
			}

			int j = 4 + 2 * n;
			list.add(new Pair(4, j));
			list.add(new Pair(3, j));
			list.add(new Pair(3, j + 1));
			list.add(new Pair(3, j + 2));
			list.add(new Pair(4, j + 2));
			list.add(new Pair(5, j + 2));
			ct += 6;

			list.add(new Pair(6, j));
			list.add(new Pair(7, j));
			list.add(new Pair(8, j));
			list.add(new Pair(9, j));
			ct += 4;
			while(j > 4) {
				j--;
				list.add(new Pair(9, j));
				ct++;
			}
			list.add(new Pair(8, 4));
			list.add(new Pair(7, 4));
			list.add(new Pair(6, 4));
			list.add(new Pair(5, 4));
			ct += 4;
		}

		pw.println(ct);
		for(Pair p : list)
			pw.println(p);
		pw.flush();
	}

	public static class Pair {
		int i, j;

		public Pair(int i, int j) {
			this.i = i;
			this.j = j;
		}

		public String toString() {
			return i + " " + j;
		}
	}

	public static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


import java.util.*;
import java.io.*;

public class C_1368 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int l = (n + 2) * 3 - 2;
		pw.println(l);
		StringBuilder sb = new StringBuilder("");
		for(int i = 0; i < 3; i++) {
			for(int j = 0; j < n + 2; j++) {
				if((i == 0 && j == 0) || (i == 2 && j == n + 1)) {
					continue;
				} else {
					sb.append(i + " " + j + "\n");
				}
			}
		}

		pw.println(sb);
		pw.flush();
	}

	public static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}


import java.util.*;
import java.io.*;

public class C_1368 {
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int l = (n + 2) * (n + 2) - 2;
		pw.println(l);
		StringBuilder sb = new StringBuilder("");
		for(int i = 0; i < n + 2; i++) {
			for(int j = 0; j < n + 2; j++) {
				if(i == j && (i == 0 || i == n + 1)) {
					continue;
				} else {
					sb.append(i + " " + j + "\n");
				}
			}
		}

		pw.println(sb);
		pw.flush();
	}

	public static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

		public int[] nextIntArray(int n) throws IOException {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();
			return array;
		}

		public Integer[] nextIntegerArray(int n) throws IOException {
			Integer[] array = new Integer[n];
			for (int i = 0; i < n; i++)
				array[i] = new Integer(nextInt());
			return array;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();
			return array;
		}

		public double[] nextDoubleArray(int n) throws IOException {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();
			return array;
		}

		public static int[] shuffle(int[] a) {
			int n = a.length;
			Random rand = new Random();
			for (int i = 0; i < n; i++) {
				int tmpIdx = rand.nextInt(n);
				int tmp = a[i];
				a[i] = a[tmpIdx];
				a[tmpIdx] = tmp;
			}
			return a;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}