import java.util.*;
import java.util.Map.Entry;

import java.io.*;
import java.math.*;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws IOException
	{
		final long mod=1000000007;
		Reader s=new Reader();
		  PrintWriter pt=new PrintWriter(System.out);
		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//		  int T=s.nextInt();
//		  int T=Integer.parseInt(br.readLine());
		  int T=1;
		  while(T-->0)
		  {
//			  String str=br.readLine();
//			  StringTokenizer st=new StringTokenizer(str," ");
//			  int n=Integer.parseInt(st.nextToken());
//			  int k=Integer.parseInt(st.nextToken());
			  long n=s.nextLong();

//			  int arr[]=new int[n];
//			  for(int i=0;i<n;i++) {
//				  arr[i]=s.nextInt();
//			  }
			  pt.println(4+3*n);
			  pt.println("0 0");
			  pt.println("1 0");
			  pt.println("1 1");
			  pt.println("0 1");
			  for(int i =1;i<=n;i++)
			  {
				  pt.println((i)+" "+(i+1));
				  pt.println((i+1)+" "+(i+1));
				  pt.println((i+1)+" "+(i));

			  }
		  }
		  pt.close();
	}
	static int fix(int x, int n) {
		if(x<0)
			return n+x;
		else
			return x;
	}
	static int binarySearch(int arr[], int first, int last, int key){
		   int mid = (first + last)/2;
		   while( first <= last ){
		      if ( arr[mid] < key ){
		        first = mid + 1;
		      }else if ( arr[mid] == key ){
		        return mid;
		      }else{
		         last = mid - 1;
		      }
		      mid = (first + last)/2;
		   }
		   return -1;
		 }
	static double gt(double x, double h, double c, double t) {
		return (x*h+(x-1)*c)/(2*x-1);
	}
	static long sq(long x) {
		return x*(x+1)*(2*x+1)/6;
	}
	static long cu(long x) {
		return x*x*(x+1)*(x+1)/4;
	}
	static void print(int a[][]) {
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[0].length;j++)
				System.out.print(a[i][j]+" ");
			System.out.println();
		}
	}
	static int max (int x, int y) {
		return (x > y)? x : y;
	}
	static int search(Pair[] p, Pair pair) {
		int l=0, r=p.length;
		while (l <= r) {
	        int m = l + (r - l) / 2;
	        if (p[m].compareTo(pair)==0)
	            return m;
	        if (p[m].compareTo(pair)<0)
	            l = m + 1;
	        else
	            r = m - 1;
	    }
	    return -1;
	}
	static void pa(int a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void pa(long a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void reverseArray(int arr[],
            int start, int end)
	{
		int temp;

		while (start < end)
		{
		    temp = arr[start];
		    arr[start] = arr[end];
		    arr[end] = temp;
		    start++;
		    end--;
		}
	}
	static boolean isPalindrome(String s) {
		int l=s.length();
		for(int i=0;i<l/2;i++)
		{
			if(s.charAt(i)!=s.charAt(l-i-1))
				return false;
		}
		return true;
	}
	static long nc2(long n, long m) {
		return (n*(n-1)/2)%m;
	}
	static long c(long a) {
		return a*(a+1)/2;
	}
	static int next(int[] arr, int 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 String toString(char [] c)
	{
		StringBuffer b=new StringBuffer("");
		for(int i=0;i<c.length;i++)
			b.append(c[i]);
		return b.toString();
	}
	static long power(long x, long y, long p)
    {
        long res = 1;
        x = x % p;

        while (y > 0)
        {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return  res;
    }
    static long modInverse(long n, long p)
    {
        return power(n, p-2, p);
    }
    static long nCrModP(long n, long r,
                                    long p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[(int) (n+1)];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[(int) n]* modInverse(fac[(int) r], p)
                % p * modInverse(fac[(int) (n-r)], p)
                                    % p) % p;
    }
	static String rev(String str)
	{
		return new StringBuffer(str).reverse().toString();
	}

	static long fastpow(long x, long y, long m)
    {
        if (y == 0)
            return 1;

        long p = fastpow(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

	static boolean isPerfectSquare(long l)
	{
		return Math.pow((long)Math.sqrt(l),2)==l;
	}

	static 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()
    static 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);
        }
    }
    static class Pair implements Comparable<Pair>{
        int a;
        int b;
        Pair(int a,int b){
            this.a=a;

            this.b=b;
        }
        public int compareTo(Pair p){
            if(a>p.a)
                return 1;
            if(a==p.a)
                return (b-p.b);
            return -1;
        }
    }
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.util.Map.Entry;

import java.io.*;
import java.math.*;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws IOException
	{
		final long mod=1000000007;
		Reader s=new Reader();
		  PrintWriter pt=new PrintWriter(System.out);
		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//		  int T=s.nextInt();
//		  int T=Integer.parseInt(br.readLine());
		  int T=1;
		  while(T-->0)
		  {
//			  String str=br.readLine();
//			  StringTokenizer st=new StringTokenizer(str," ");
//			  int n=Integer.parseInt(st.nextToken());
//			  int k=Integer.parseInt(st.nextToken());
			  long n=s.nextLong();

//			  int arr[]=new int[n];
//			  for(int i=0;i<n;i++) {
//				  arr[i]=s.nextInt();
//			  }
			  pt.println(8*n);
			  for(int i =0;i<n;i++)
			  {
				  for(int j=0;j<3;j++)
					  for(int k=0;k<3;k++)
						  if(k!=j||j==1)
						  pt.println((4*i+j)+" "+k);
			  }
		  }
		  pt.close();
	}
	static int fix(int x, int n) {
		if(x<0)
			return n+x;
		else
			return x;
	}
	static int binarySearch(int arr[], int first, int last, int key){
		   int mid = (first + last)/2;
		   while( first <= last ){
		      if ( arr[mid] < key ){
		        first = mid + 1;
		      }else if ( arr[mid] == key ){
		        return mid;
		      }else{
		         last = mid - 1;
		      }
		      mid = (first + last)/2;
		   }
		   return -1;
		 }
	static double gt(double x, double h, double c, double t) {
		return (x*h+(x-1)*c)/(2*x-1);
	}
	static long sq(long x) {
		return x*(x+1)*(2*x+1)/6;
	}
	static long cu(long x) {
		return x*x*(x+1)*(x+1)/4;
	}
	static void print(int a[][]) {
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[0].length;j++)
				System.out.print(a[i][j]+" ");
			System.out.println();
		}
	}
	static int max (int x, int y) {
		return (x > y)? x : y;
	}
	static int search(Pair[] p, Pair pair) {
		int l=0, r=p.length;
		while (l <= r) {
	        int m = l + (r - l) / 2;
	        if (p[m].compareTo(pair)==0)
	            return m;
	        if (p[m].compareTo(pair)<0)
	            l = m + 1;
	        else
	            r = m - 1;
	    }
	    return -1;
	}
	static void pa(int a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void pa(long a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void reverseArray(int arr[],
            int start, int end)
	{
		int temp;

		while (start < end)
		{
		    temp = arr[start];
		    arr[start] = arr[end];
		    arr[end] = temp;
		    start++;
		    end--;
		}
	}
	static boolean isPalindrome(String s) {
		int l=s.length();
		for(int i=0;i<l/2;i++)
		{
			if(s.charAt(i)!=s.charAt(l-i-1))
				return false;
		}
		return true;
	}
	static long nc2(long n, long m) {
		return (n*(n-1)/2)%m;
	}
	static long c(long a) {
		return a*(a+1)/2;
	}
	static int next(int[] arr, int 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 String toString(char [] c)
	{
		StringBuffer b=new StringBuffer("");
		for(int i=0;i<c.length;i++)
			b.append(c[i]);
		return b.toString();
	}
	static long power(long x, long y, long p)
    {
        long res = 1;
        x = x % p;

        while (y > 0)
        {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return  res;
    }
    static long modInverse(long n, long p)
    {
        return power(n, p-2, p);
    }
    static long nCrModP(long n, long r,
                                    long p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[(int) (n+1)];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[(int) n]* modInverse(fac[(int) r], p)
                % p * modInverse(fac[(int) (n-r)], p)
                                    % p) % p;
    }
	static String rev(String str)
	{
		return new StringBuffer(str).reverse().toString();
	}

	static long fastpow(long x, long y, long m)
    {
        if (y == 0)
            return 1;

        long p = fastpow(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

	static boolean isPerfectSquare(long l)
	{
		return Math.pow((long)Math.sqrt(l),2)==l;
	}

	static 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()
    static 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);
        }
    }
    static class Pair implements Comparable<Pair>{
        int a;
        int b;
        Pair(int a,int b){
            this.a=a;

            this.b=b;
        }
        public int compareTo(Pair p){
            if(a>p.a)
                return 1;
            if(a==p.a)
                return (b-p.b);
            return -1;
        }
    }
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.util.Map.Entry;

import java.io.*;
import java.math.*;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws IOException
	{
		final long mod=1000000007;
		Reader s=new Reader();
		  PrintWriter pt=new PrintWriter(System.out);
		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//		  int T=s.nextInt();
//		  int T=Integer.parseInt(br.readLine());
		  int T=1;
		  while(T-->0)
		  {
//			  String str=br.readLine();
//			  StringTokenizer st=new StringTokenizer(str," ");
//			  int n=Integer.parseInt(st.nextToken());
//			  int k=Integer.parseInt(st.nextToken());
			  long n=s.nextLong();

//			  int arr[]=new int[n];
//			  for(int i=0;i<n;i++) {
//				  arr[i]=s.nextInt();
//			  }
			  pt.println(8*n);
			  for(int i =0;i<n;i++)
			  {
				  for(int j=0;j<3;j++)
					  for(int k=0;k<3;k++)
						  pt.println((4*i+j)+" "+k);
			  }
		  }
		  pt.close();
	}
	static int fix(int x, int n) {
		if(x<0)
			return n+x;
		else
			return x;
	}
	static int binarySearch(int arr[], int first, int last, int key){
		   int mid = (first + last)/2;
		   while( first <= last ){
		      if ( arr[mid] < key ){
		        first = mid + 1;
		      }else if ( arr[mid] == key ){
		        return mid;
		      }else{
		         last = mid - 1;
		      }
		      mid = (first + last)/2;
		   }
		   return -1;
		 }
	static double gt(double x, double h, double c, double t) {
		return (x*h+(x-1)*c)/(2*x-1);
	}
	static long sq(long x) {
		return x*(x+1)*(2*x+1)/6;
	}
	static long cu(long x) {
		return x*x*(x+1)*(x+1)/4;
	}
	static void print(int a[][]) {
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[0].length;j++)
				System.out.print(a[i][j]+" ");
			System.out.println();
		}
	}
	static int max (int x, int y) {
		return (x > y)? x : y;
	}
	static int search(Pair[] p, Pair pair) {
		int l=0, r=p.length;
		while (l <= r) {
	        int m = l + (r - l) / 2;
	        if (p[m].compareTo(pair)==0)
	            return m;
	        if (p[m].compareTo(pair)<0)
	            l = m + 1;
	        else
	            r = m - 1;
	    }
	    return -1;
	}
	static void pa(int a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void pa(long a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void reverseArray(int arr[],
            int start, int end)
	{
		int temp;

		while (start < end)
		{
		    temp = arr[start];
		    arr[start] = arr[end];
		    arr[end] = temp;
		    start++;
		    end--;
		}
	}
	static boolean isPalindrome(String s) {
		int l=s.length();
		for(int i=0;i<l/2;i++)
		{
			if(s.charAt(i)!=s.charAt(l-i-1))
				return false;
		}
		return true;
	}
	static long nc2(long n, long m) {
		return (n*(n-1)/2)%m;
	}
	static long c(long a) {
		return a*(a+1)/2;
	}
	static int next(int[] arr, int 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 String toString(char [] c)
	{
		StringBuffer b=new StringBuffer("");
		for(int i=0;i<c.length;i++)
			b.append(c[i]);
		return b.toString();
	}
	static long power(long x, long y, long p)
    {
        long res = 1;
        x = x % p;

        while (y > 0)
        {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return  res;
    }
    static long modInverse(long n, long p)
    {
        return power(n, p-2, p);
    }
    static long nCrModP(long n, long r,
                                    long p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[(int) (n+1)];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[(int) n]* modInverse(fac[(int) r], p)
                % p * modInverse(fac[(int) (n-r)], p)
                                    % p) % p;
    }
	static String rev(String str)
	{
		return new StringBuffer(str).reverse().toString();
	}

	static long fastpow(long x, long y, long m)
    {
        if (y == 0)
            return 1;

        long p = fastpow(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

	static boolean isPerfectSquare(long l)
	{
		return Math.pow((long)Math.sqrt(l),2)==l;
	}

	static 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()
    static 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);
        }
    }
    static class Pair implements Comparable<Pair>{
        int a;
        int b;
        Pair(int a,int b){
            this.a=a;

            this.b=b;
        }
        public int compareTo(Pair p){
            if(a>p.a)
                return 1;
            if(a==p.a)
                return (b-p.b);
            return -1;
        }
    }
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.util.*;
import java.util.Map.Entry;

import java.io.*;
import java.math.*;
import static java.util.stream.Collectors.*;
import static java.util.Map.Entry.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws IOException
	{
		final long mod=1000000007;
		Reader s=new Reader();
		  PrintWriter pt=new PrintWriter(System.out);
		  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//		  int T=s.nextInt();
//		  int T=Integer.parseInt(br.readLine());
		  int T=1;
		  while(T-->0)
		  {
//			  String str=br.readLine();
//			  StringTokenizer st=new StringTokenizer(str," ");
//			  int n=Integer.parseInt(st.nextToken());
//			  int k=Integer.parseInt(st.nextToken());
			  long n=s.nextLong();

//			  int arr[]=new int[n];
//			  for(int i=0;i<n;i++) {
//				  arr[i]=s.nextInt();
//			  }
			  pt.println(6*n);
			  for(int i =0;i<n;i++)
			  {
				  for(int j=0;j<3;j++)
					  for(int k=0;k<3;k++)
						  if(k!=j||j==1)
						  pt.println((4*i+j)+" "+k);
			  }
		  }
		  pt.close();
	}
	static int fix(int x, int n) {
		if(x<0)
			return n+x;
		else
			return x;
	}
	static int binarySearch(int arr[], int first, int last, int key){
		   int mid = (first + last)/2;
		   while( first <= last ){
		      if ( arr[mid] < key ){
		        first = mid + 1;
		      }else if ( arr[mid] == key ){
		        return mid;
		      }else{
		         last = mid - 1;
		      }
		      mid = (first + last)/2;
		   }
		   return -1;
		 }
	static double gt(double x, double h, double c, double t) {
		return (x*h+(x-1)*c)/(2*x-1);
	}
	static long sq(long x) {
		return x*(x+1)*(2*x+1)/6;
	}
	static long cu(long x) {
		return x*x*(x+1)*(x+1)/4;
	}
	static void print(int a[][]) {
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[0].length;j++)
				System.out.print(a[i][j]+" ");
			System.out.println();
		}
	}
	static int max (int x, int y) {
		return (x > y)? x : y;
	}
	static int search(Pair[] p, Pair pair) {
		int l=0, r=p.length;
		while (l <= r) {
	        int m = l + (r - l) / 2;
	        if (p[m].compareTo(pair)==0)
	            return m;
	        if (p[m].compareTo(pair)<0)
	            l = m + 1;
	        else
	            r = m - 1;
	    }
	    return -1;
	}
	static void pa(int a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void pa(long a[])
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();

	}
	static void reverseArray(int arr[],
            int start, int end)
	{
		int temp;

		while (start < end)
		{
		    temp = arr[start];
		    arr[start] = arr[end];
		    arr[end] = temp;
		    start++;
		    end--;
		}
	}
	static boolean isPalindrome(String s) {
		int l=s.length();
		for(int i=0;i<l/2;i++)
		{
			if(s.charAt(i)!=s.charAt(l-i-1))
				return false;
		}
		return true;
	}
	static long nc2(long n, long m) {
		return (n*(n-1)/2)%m;
	}
	static long c(long a) {
		return a*(a+1)/2;
	}
	static int next(int[] arr, int 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 String toString(char [] c)
	{
		StringBuffer b=new StringBuffer("");
		for(int i=0;i<c.length;i++)
			b.append(c[i]);
		return b.toString();
	}
	static long power(long x, long y, long p)
    {
        long res = 1;
        x = x % p;

        while (y > 0)
        {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return  res;
    }
    static long modInverse(long n, long p)
    {
        return power(n, p-2, p);
    }
    static long nCrModP(long n, long r,
                                    long p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[(int) (n+1)];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[(int) n]* modInverse(fac[(int) r], p)
                % p * modInverse(fac[(int) (n-r)], p)
                                    % p) % p;
    }
	static String rev(String str)
	{
		return new StringBuffer(str).reverse().toString();
	}

	static long fastpow(long x, long y, long m)
    {
        if (y == 0)
            return 1;

        long p = fastpow(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

	static boolean isPerfectSquare(long l)
	{
		return Math.pow((long)Math.sqrt(l),2)==l;
	}

	static 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()
    static 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);
        }
    }
    static class Pair implements Comparable<Pair>{
        int a;
        int b;
        Pair(int a,int b){
            this.a=a;

            this.b=b;
        }
        public int compareTo(Pair p){
            if(a>p.a)
                return 1;
            if(a==p.a)
                return (b-p.b);
            return -1;
        }
    }
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
}


import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class cGlobal8 implements Runnable{

    public static void main(String[] args) {
    	try{
            new Thread(null, new cGlobal8(), "process", 1<<26).start();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
	public void run() {
		FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), false);
		//PrintWriter out = new PrintWriter("file.out");
		Task solver = new Task();
		//int t = scan.nextInt();
		int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {
		static final int inf = Integer.MAX_VALUE;

		public void solve(int testNumber, FastReader sc, PrintWriter out) {
			int N = sc.nextInt();

			StringBuilder ans = new StringBuilder("");
			if(N % 2 == 0) {
				int count = 0;
				for(int i = -2; i < N + (N/2) + 1; i++) {
					ans.append(i + " 0" + "\n");
					count++;
				}
				for(int i = 0; i < N + (N/2) - 1; i++) {
					if((i+1) % 3 == 0) {
						continue;
					}
					ans.append(i + " -1" + "\n");
					ans.append(i + " 1" + "\n");
					count+=2;
				}

				for(int i = -1; i >= -3; i--) {
					ans.append("-2 " + i + "\n");
					ans.append((N + N/2) + " " + i + "\n");
					count+=2;
				}

				for(int i = -1; i < N + N/2; i++) {
					ans.append(i + " -3" + "\n");
					count++;
				}

				out.println(count);
				out.println(ans);
			} else {
				int count = 0;
				for(int i = -2; i < N + (N/2) + 1; i++) {
					ans.append(i + " 0" + "\n");
					count++;
				}
				for(int i = 0; i < N + (N/2); i++) {
					if((i+1) % 3 == 0) {
						continue;
					}
					ans.append(i + " -1" + "\n");
					ans.append(i + " 1" + "\n");
					count += 2;
				}

				ans.append((N + (N/2)) + " 1" + "\n");
				ans.append("-3 0" + "\n");
				ans.append("-3 -1" + "\n");
				ans.append("-3 -2" + "\n");
				ans.append("-3 -3" + "\n");
				ans.append((N + N/2 - 1 + " -2") + "\n");
				ans.append((N + N/2 - 1 + " -3") + "\n");
				count += 7;

				for(int i = -2; i < N + N/2 - 1; i++) {
					ans.append(i + " -3" + "\n");
					count++;
				}

				out.println(count);
				out.println(ans);
			}
		}
	}
	static long binpow(long a, long b, long m) {
		a %= m;
		long res = 1;
		while (b > 0) {
			if ((b & 1) == 1)
				res = res * a % m;
			a = a * a % m;
			b >>= 1;
		}
		return res;
	}
	static void sort(int[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static void sort(long[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static class tup implements Comparable<tup>, Comparator<tup>{
		int a, b;
		tup(int a,int b){
			this.a=a;
			this.b=b;
		}
		public tup() {
		}
		@Override
		public int compareTo(tup o){
			return Integer.compare(b,o.b);
		}
		@Override
		public int compare(tup o1, tup o2) {
			return Integer.compare(o1.b, o2.b);
		}

		@Override
	    public int hashCode() {
			return Objects.hash(a, b);
	    }

	    @Override
	    public boolean equals(Object obj) {
	    	if (this == obj)
                return true;
	    	if (obj == null)
                return false;
	    	if (getClass() != obj.getClass())
                return false;
	    	tup other = (tup) obj;
	    	return a==other.a && b==other.b;
	    }

	    @Override
	    public String toString() {
	    	return a + " " + b;
	    }
	}

	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

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

}


import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class cGlobal8 implements Runnable{

    public static void main(String[] args) {
    	try{
            new Thread(null, new cGlobal8(), "process", 1<<26).start();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
	public void run() {
		FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		//PrintWriter out = new PrintWriter("file.out");
		Task solver = new Task();
		//int t = scan.nextInt();
		int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {
		static final int inf = Integer.MAX_VALUE;

		public void solve(int testNumber, FastReader sc, PrintWriter out) {
			int N = sc.nextInt();

			if(N % 2 == 0) {
				for(int i = -2; i < N + (N/2) + 1; i++) {
					out.println(i + " 0");
				}
				for(int i = 0; i < N + (N/2) - 1; i++) {
					if((i+1) % 3 == 0) {
						continue;
					}
					out.println(i + " -1");
					out.println(i + " 1");
				}

				for(int i = -1; i >= -3; i--) {
					out.println("-2 " + i);
					out.println((N + N/2) + " " + i);
				}

				for(int i = -1; i < N + N/2; i++) {
					out.println(i + " -3");
				}
			} else {
				for(int i = -2; i < N + (N/2) + 1; i++) {
					out.println(i + " 0");
				}
				for(int i = 0; i < N + (N/2); i++) {
					if((i+1) % 3 == 0) {
						continue;
					}
					out.println(i + " -1");
					out.println(i + " 1");
				}

				out.println((N + (N/2)) + " 1");
				out.println("-3 0");
				out.println("-3 -1");
				out.println("-3 -2");
				out.println("-3 -3");
				out.println((N + N/2 - 1 + " -2"));
				out.println((N + N/2 - 1 + " -3"));

				for(int i = -2; i < N + N/2 - 1; i++) {
					out.println(i + " -3");
				}
			}
		}
	}
	static long binpow(long a, long b, long m) {
		a %= m;
		long res = 1;
		while (b > 0) {
			if ((b & 1) == 1)
				res = res * a % m;
			a = a * a % m;
			b >>= 1;
		}
		return res;
	}
	static void sort(int[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static void sort(long[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static class tup implements Comparable<tup>, Comparator<tup>{
		int a, b;
		tup(int a,int b){
			this.a=a;
			this.b=b;
		}
		public tup() {
		}
		@Override
		public int compareTo(tup o){
			return Integer.compare(b,o.b);
		}
		@Override
		public int compare(tup o1, tup o2) {
			return Integer.compare(o1.b, o2.b);
		}

		@Override
	    public int hashCode() {
			return Objects.hash(a, b);
	    }

	    @Override
	    public boolean equals(Object obj) {
	    	if (this == obj)
                return true;
	    	if (obj == null)
                return false;
	    	if (getClass() != obj.getClass())
                return false;
	    	tup other = (tup) obj;
	    	return a==other.a && b==other.b;
	    }

	    @Override
	    public String toString() {
	    	return a + " " + b;
	    }
	}

	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

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

}


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

public class EvenPicture {

	public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        out.println((n+1)*3 + 1);
        for(int i=0;i<=n+2;i++) {
        	out.println(i+" "+i);
        	if(i<n+2) {
        		out.println((i+1)+" "+i);
        		out.println(i+" "+(i+1));
        	}
        }
        out.flush();
	}

	static class FastScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

		String next() {
			while(!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				}catch(IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

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

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

		int[] readArray(int n) {
			int a[] = new int[n];
			for(int i=0;i<n;i++) a[i] = nextInt();
			return a;
		}

		long[] readArray(int n,long x) {
			long a[] = new long[n];
			for(int i=0;i<n;i++) a[i] = nextLong();
			return a;
		}

	}

	static boolean arrayEquals(char a[], char b[]) {
		int n = a.length;
		boolean verdict = true;
		for(int i=0;i<n;i++) {
			if(a[i]!=b[i]) {
				verdict = false;break;
			}
		}
		return verdict;
	}

	static long lcm(long a, long b) {
		return (a*b)/gcd(a,b);
	}

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


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

public class EvenPicture {

	public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        out.println((n+1)*3 + 1);
        for(int i=0;i<=n+1;i++) {
        	out.println(i+" "+i);
        	if(i<n+1) {
        		out.println((i+1)+" "+i);
        		out.println(i+" "+(i+1));
        	}
        }
        out.flush();
	}

	static class FastScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

		String next() {
			while(!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				}catch(IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

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

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

		int[] readArray(int n) {
			int a[] = new int[n];
			for(int i=0;i<n;i++) a[i] = nextInt();
			return a;
		}

		long[] readArray(int n,long x) {
			long a[] = new long[n];
			for(int i=0;i<n;i++) a[i] = nextLong();
			return a;
		}

	}

	static boolean arrayEquals(char a[], char b[]) {
		int n = a.length;
		boolean verdict = true;
		for(int i=0;i<n;i++) {
			if(a[i]!=b[i]) {
				verdict = false;break;
			}
		}
		return verdict;
	}

	static long lcm(long a, long b) {
		return (a*b)/gcd(a,b);
	}

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


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

public class EvenPicture {

	public static void main(String[] args) {
        FastScanner in = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        int x = 0;
        out.println((n*5)+n+1);
        out.println("-1 0");
        for(int i=0;i<2*n;i++) {
        	if(i%2==0) {
        		out.println(x+" 0");
        		out.println(x+" 1");out.println(x+" 2");out.println(x+" -1");out.println(x+" -2");
        	}
        	else {
        		out.println(x+" 0");
        	}
        	x++;
        }
        out.flush();
	}

	static class FastScanner {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

		String next() {
			while(!st.hasMoreTokens())
				try {
					st = new StringTokenizer(br.readLine());
				}catch(IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

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

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

		int[] readArray(int n) {
			int a[] = new int[n];
			for(int i=0;i<n;i++) a[i] = nextInt();
			return a;
		}

		long[] readArray(int n,long x) {
			long a[] = new long[n];
			for(int i=0;i<n;i++) a[i] = nextLong();
			return a;
		}

	}

	static boolean arrayEquals(char a[], char b[]) {
		int n = a.length;
		boolean verdict = true;
		for(int i=0;i<n;i++) {
			if(a[i]!=b[i]) {
				verdict = false;break;
			}
		}
		return verdict;
	}

	static long lcm(long a, long b) {
		return (a*b)/gcd(a,b);
	}

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


import java.util.*;
// scanner.nextInt();
public class Solution {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

                int n = scanner.nextInt();

                int x = 0;
                int y = 0;

                System.out.println(1 + " " + 1);
                for(int i = 0; i < n+1; ++i)
                {
                    System.out.println(x + " " + y);
                    System.out.println((x+1) + " " + y);
                    System.out.println(x + " " + (y+1));
                    --x;
                    --y;
                }

    }

}


import java.util.*;
// scanner.nextInt();
public class Solution {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

                int n = scanner.nextInt();

                int x = 0;
                int y = 0;

                System.out.println((1+3*(n+1)));
                System.out.println(1 + " " + 1);
                for(int i = 0; i < n+1; ++i)
                {
                    System.out.println(x + " " + y);
                    System.out.println((x+1) + " " + y);
                    System.out.println(x + " " + (y+1));
                    --x;
                    --y;
                }

    }

}


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

public class gfg  {

    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException{
        //Reader.init(System.in);

        Reader.init(System.in);
        int t = 1;//Reader.nextInt();
        while(t-->0){
           solve();
        }
            out.close();
    }

    static ArrayList<Integer>[] graph;
    static int n=0;
    static int m=0;
    static boolean[] vis;
    static int[] color;
    static long mod =1000000007;
    static int min=-1;
    static boolean invalid=false;
    static int[] dx = {0,0,-1,1};
    static int[] dy = {1,-1,0,0};
    static int[] count;
    static int max=0;
    static int total=0;

    static void solve()throws IOException{
        int n= Reader.nextInt();

        total = (n-1)*2 + 3 + n;

        if(n==1){
            out.println(5);
            out.println(1+" "+1);
            out.println((0)+" "+(1));
            out.println(1+" "+0);
            out.println(1+" "+2);
            out.println(2+" "+1);
            return;
        }
        out.println(total);
        for(int i=1;i<=n;i++){
            int j=i;
            if(i==n){
                out.println(i+" "+j);
                out.println((i+1)+" "+(j));
                out.println(i+" "+(j+1));
                out.println((i+1)+" "+(j+1));
            }
            else{
                out.println(i+" "+j);
                out.println((i+1)+" "+(j));
                out.println(i+" "+(j+1));
            }
        }

    }

    static void dfs(int a){
        vis[a] = true;
        count[color[a]]++;
        max = Math.max(count[color[a]],max);
        total++;
        for(int i : graph[a]){
           if(!vis[i]){
                dfs(i);
           }
        }
    }

    // ggratest common divisor
    static int gcd(int a , int b){
        if(b==0)
            return a;
        else
            return gcd(b,a%b);
    }

    // least common multiple
    static int lcm(int a, int b){
        return (a*b)/gcd(a,b);
    }

    // a^b
    static long fastpow(long a, long b){
        long res = 1;a=a%mod;
        while(b>0){
            if(b%2==1)
                res = (res*a)%mod;
            a = (a*a)%mod;
            b = b>>1;
        }
        return res;
    }

    // priority queue with comparator
    // PriorityQueue<Interval> pq = new PriorityQueue<>(new Comparator<Interval>() {
    //             public int compare(Interval a, Interval b){
    //                 int diff1 = a.r - a.l;
    //                 int diff2 = b.r - b.l;

    //                 if(diff1 == diff2){
    //                     return a.l - b.l;
    //                 }

    //                 return diff2 - diff1;
    //             }
    // });
}

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 newcomparator implements Comparator<Integer>{
    //@Override
    public int compare(Integer a, Integer  b){
        return a<=b?1:-1;
    }
 }
class node {
    int a;
    long b;// cost to rreach\
    node(int s,long va){
        a=s;
        b=va;
    }
}
class mergesort{
    static void sort(int l, int h, int[] arr){
        if(l<h){
            int mid = (l+h)/2;

            sort(l,mid,arr);
            sort(mid+1,h,arr);
            merge(l,mid,h,arr);
        }
    }
    static void merge(int l, int m , int h , int [] arr){

        int[] left = new int[m-l+1];
        int[] right = new int[h-m];
        for(int i= 0 ;i< m-l+1;i++){
            left[i] = arr[l+i];
        }
        for(int i=0;i<h-m;i++){
            right[i] = arr[m+1+i];
        }
        //now left and right arrays are assumed to be sorted and we have tp merge them together
        // int the original aaray.
        int i=l;
        int lindex = 0;
        int rindex =  0;

        while(lindex<m-l+1 && rindex<h-m){
            if(left[lindex]>=right[rindex]){
                arr[i]=left[lindex];
                lindex++;
                i++;
            }
            else{
                arr[i]=right[rindex];
                rindex++;
                i++;
            }
        }
        while(lindex<m-l+1){
            arr[i]=left[lindex];
            lindex++;
            i++;
        }
        while(rindex<h-m){
            arr[i]=right[rindex];
            rindex++;
            i++;
        }
    }

}


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

public class gfg  {

    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException{
        //Reader.init(System.in);

        Reader.init(System.in);
        int t = 1;//Reader.nextInt();
        while(t-->0){
           solve();
        }
            out.close();
    }

    static ArrayList<Integer>[] graph;
    static int n=0;
    static int m=0;
    static boolean[] vis;
    static int[] color;
    static long mod =1000000007;
    static int min=-1;
    static boolean invalid=false;
    static int[] dx = {0,0,1,1};
    static int[] dy = {0,1,0,0};
    static int[] count;
    static int max=0;
    static int total=0;

    static void solve()throws IOException{
        int n= Reader.nextInt();
        boolean[][] arr = new boolean[n+5][n+5];
        int total=0;
        arr[n+1][n+1]=true;
        for(int i=0;i<=n;i++){
            for(int k=0;k<3;k++){
                int x = i+dx[k];
                int y = i+dy[k];
                arr[x][y]=true;
            }
        }
        for(int i=0;i<n+5;i++){
            for(int j=0;j<n+5;j++){
                if(arr[i][j]==true)
                    total++;
            }
        }
        out.println(total);
        for(int i=0;i<n+5;i++){
            for(int j=0;j<n+5;j++){
                if(arr[i][j]==true)
                    out.println(i+" "+j);
            }
        }
    }

    static void dfs(int a){
        vis[a] = true;
        count[color[a]]++;
        max = Math.max(count[color[a]],max);
        total++;
        for(int i : graph[a]){
           if(!vis[i]){
                dfs(i);
           }
        }
    }

    // ggratest common divisor
    static int gcd(int a , int b){
        if(b==0)
            return a;
        else
            return gcd(b,a%b);
    }

    // least common multiple
    static int lcm(int a, int b){
        return (a*b)/gcd(a,b);
    }

    // a^b
    static long fastpow(long a, long b){
        long res = 1;a=a%mod;
        while(b>0){
            if(b%2==1)
                res = (res*a)%mod;
            a = (a*a)%mod;
            b = b>>1;
        }
        return res;
    }

    // priority queue with comparator
    // PriorityQueue<Interval> pq = new PriorityQueue<>(new Comparator<Interval>() {
    //             public int compare(Interval a, Interval b){
    //                 int diff1 = a.r - a.l;
    //                 int diff2 = b.r - b.l;

    //                 if(diff1 == diff2){
    //                     return a.l - b.l;
    //                 }

    //                 return diff2 - diff1;
    //             }
    // });
}

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 newcomparator implements Comparator<Integer>{
    //@Override
    public int compare(Integer a, Integer  b){
        return a<=b?1:-1;
    }
 }
class node {
    int a;
    long b;// cost to rreach\
    node(int s,long va){
        a=s;
        b=va;
    }
}
class mergesort{
    static void sort(int l, int h, int[] arr){
        if(l<h){
            int mid = (l+h)/2;

            sort(l,mid,arr);
            sort(mid+1,h,arr);
            merge(l,mid,h,arr);
        }
    }
    static void merge(int l, int m , int h , int [] arr){

        int[] left = new int[m-l+1];
        int[] right = new int[h-m];
        for(int i= 0 ;i< m-l+1;i++){
            left[i] = arr[l+i];
        }
        for(int i=0;i<h-m;i++){
            right[i] = arr[m+1+i];
        }
        //now left and right arrays are assumed to be sorted and we have tp merge them together
        // int the original aaray.
        int i=l;
        int lindex = 0;
        int rindex =  0;

        while(lindex<m-l+1 && rindex<h-m){
            if(left[lindex]>=right[rindex]){
                arr[i]=left[lindex];
                lindex++;
                i++;
            }
            else{
                arr[i]=right[rindex];
                rindex++;
                i++;
            }
        }
        while(lindex<m-l+1){
            arr[i]=left[lindex];
            lindex++;
            i++;
        }
        while(rindex<h-m){
            arr[i]=right[rindex];
            rindex++;
            i++;
        }
    }

}


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

public class gfg  {

    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException{
        //Reader.init(System.in);

        Reader.init(System.in);
        int t = 1;//Reader.nextInt();
        while(t-->0){
           solve();
        }
            out.close();
    }

    static ArrayList<Integer>[] graph;
    static int n=0;
    static int m=0;
    static boolean[] vis;
    static int[] color;
    static long mod =1000000007;
    static int min=-1;
    static boolean invalid=false;
    static int[] dx = {0,0,-1,1};
    static int[] dy = {1,-1,0,0};
    static int[] count;
    static int max=0;
    static int total=0;

    static void solve()throws IOException{
        int k= Reader.nextInt();
        int n = 2000;
        int m = 2000;
        int[][] arr = new int[2000][2000];
        int count=0;
        int total =0;
        long min =Long.MAX_VALUE;
        int ma=0;
        int mb =0;
        for(int i=1;i<=k;i++){
            long a = i;
            long b = k-i;
            if(a*b<min && a*b>=k){
                ma = (int)a;
                mb = (int )b;
                min = a*b;
            }
           // out.println(ma+" "+mb+" "+a+" "+b);
        }
        if(k==1){
            ma=1;
            mb=1;
        }
        if(k==2){
            ma=2;
            mb=1;
        }
        if(k==3){
            ma=2;
            mb=2;
        }
        boolean[][] marked = new boolean[n][m];
        for(int i=1;i<=ma;i++){
            for(int j=1;j<=mb;j++){
                if(count<k){
                    count++;
                    if(!marked[i][j])
                        total++;
                    marked[i][j]=true;
                    for(int u =0;u<4;u++){
                        int x = i+dx[u];
                        int y = j+dy[u];
                        if(!marked[x][y] && count<=k) {
                            marked[x][y]=true;
                            total++;
                        }
                    }
                }
            }
        }

        out.println(total);
        for(int i=0;i<=1200;i++){
            for(int j=0;j<=1200;j++){
                if(marked[i][j]){
                    out.println(i+" "+j);
                }
            }
        }

    }

    static void dfs(int a){
        vis[a] = true;
        count[color[a]]++;
        max = Math.max(count[color[a]],max);
        total++;
        for(int i : graph[a]){
           if(!vis[i]){
                dfs(i);
           }
        }
    }

    // ggratest common divisor
    static int gcd(int a , int b){
        if(b==0)
            return a;
        else
            return gcd(b,a%b);
    }

    // least common multiple
    static int lcm(int a, int b){
        return (a*b)/gcd(a,b);
    }

    // a^b
    static long fastpow(long a, long b){
        long res = 1;a=a%mod;
        while(b>0){
            if(b%2==1)
                res = (res*a)%mod;
            a = (a*a)%mod;
            b = b>>1;
        }
        return res;
    }

    // priority queue with comparator
    // PriorityQueue<Interval> pq = new PriorityQueue<>(new Comparator<Interval>() {
    //             public int compare(Interval a, Interval b){
    //                 int diff1 = a.r - a.l;
    //                 int diff2 = b.r - b.l;

    //                 if(diff1 == diff2){
    //                     return a.l - b.l;
    //                 }

    //                 return diff2 - diff1;
    //             }
    // });
}

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 newcomparator implements Comparator<Integer>{
    //@Override
    public int compare(Integer a, Integer  b){
        return a<=b?1:-1;
    }
 }
class node {
    int a;
    long b;// cost to rreach\
    node(int s,long va){
        a=s;
        b=va;
    }
}
class mergesort{
    static void sort(int l, int h, int[] arr){
        if(l<h){
            int mid = (l+h)/2;

            sort(l,mid,arr);
            sort(mid+1,h,arr);
            merge(l,mid,h,arr);
        }
    }
    static void merge(int l, int m , int h , int [] arr){

        int[] left = new int[m-l+1];
        int[] right = new int[h-m];
        for(int i= 0 ;i< m-l+1;i++){
            left[i] = arr[l+i];
        }
        for(int i=0;i<h-m;i++){
            right[i] = arr[m+1+i];
        }
        //now left and right arrays are assumed to be sorted and we have tp merge them together
        // int the original aaray.
        int i=l;
        int lindex = 0;
        int rindex =  0;

        while(lindex<m-l+1 && rindex<h-m){
            if(left[lindex]>=right[rindex]){
                arr[i]=left[lindex];
                lindex++;
                i++;
            }
            else{
                arr[i]=right[rindex];
                rindex++;
                i++;
            }
        }
        while(lindex<m-l+1){
            arr[i]=left[lindex];
            lindex++;
            i++;
        }
        while(rindex<h-m){
            arr[i]=right[rindex];
            rindex++;
            i++;
        }
    }

}


import java.util.Scanner;

public class Main {

	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		StringBuilder sb=new StringBuilder();

		for(int i=1;i>=-3;i--)
		{
			if(i==1)
			{
				for(int j=2;j<=2+n-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
			else if(i==0)
			{
				for(int j=0;j<=n+4-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
			else if(i==-1)
			{
				sb.append(i+" "+0);
				sb.append("\n");

				for(int j=2;j<=2+n-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}

				sb.append(i+" "+(n+4-1));
			}
			else if(i==-2)
			{
				sb.append(i+" "+0);
				sb.append("\n");
				sb.append(i+" "+(n+4-1));
				sb.append("\n");
			}
			else
			{
				for(int j=0;j<=n+4-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
		}

		System.out.println(4*n+12);

		System.out.println(sb);

	}

}


import java.util.Scanner;

public class Main {

	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);

		StringBuilder sb=new StringBuilder();

		int n=s.nextInt();

		int count=2;

		sb.append(0+" "+0);
		sb.append("\n");
		sb.append(0+" "+1);
		sb.append("\n");

		for(int i=1;i<n+1;i++)
		{
			for(int j=i-1;j<=i+1;j++)
			{
				sb.append(i+" "+j);
				sb.append("\n");

				count++;
			}
		}

		sb.append(n+1+" "+n);
		sb.append("\n");
		sb.append(n+1+" "+(n+1));
		sb.append("\n");

		System.out.println(count+2);
		System.out.println(sb);

	}

}


import java.util.Scanner;

public class Main {

	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		StringBuilder sb=new StringBuilder();

		for(int i=1;i>=-3;i--)
		{
			if(i==1)
			{
				for(int j=2;j<=2+n-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
			else if(i==0)
			{
				for(int j=0;j<=n+4-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
			else if(i==-1)
			{
				sb.append(i+" "+0);
				sb.append("\n");

				for(int j=2;j<=2+n-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}

				sb.append(i+" "+(n+4-1));
				sb.append("\n");
			}
			else if(i==-2)
			{
				sb.append(i+" "+0);
				sb.append("\n");
				sb.append(i+" "+(n+4-1));
				sb.append("\n");
			}
			else
			{
				for(int j=0;j<=n+4-1;j++)
				{
					sb.append(i+" "+j);
					sb.append("\n");
				}
			}
		}

		System.out.println((4*n)+12);

		System.out.println(sb);

	}

}


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

public class C {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

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

    static FastReader s = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    private static int[] rai(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextInt();
        }
        return arr;
    }

    private static int[][] rai(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextInt();
            }
        }
        return arr;
    }

    private static long[] ral(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextLong();
        }
        return arr;
    }

    private static long[][] ral(int n, int m) {
        long[][] arr = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextLong();
            }
        }
        return arr;
    }

    private static int ri() {
        return s.nextInt();
    }

    private static long rl() {
        return s.nextLong();
    }

    private static String rs() {
        return s.next();
    }

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

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
//        int t = ri();
        int t=1;
        while (t-- > 0)
        {
            int n=ri();
            int count=0;
            StringBuilder str=new StringBuilder();
            int i=0,j=0;
            int val=n+n-1+4;
            for(int x=0;x<val;x++)
            {
                count++;
                str.append(i).append(" ").append(j).append("\n");
                j++;
            }
            i=-1;j=0;

            for(int x=0;x<=n;x++)
            {
                if(x%2==0) {
                    int v1=i,v2=j;
//                    for (int m = 0; m < 5; m++) {
                        count+=5;
                        str.append(v1).append(" ").append(v2).append("\n");
                    str.append(v1-1).append(" ").append(v2).append("\n");
                    str.append(v1-1).append(" ").append(v2+1).append("\n");
                    str.append(v1-1).append(" ").append(v2+2).append("\n");
                    str.append(v1).append(" ").append(v2+2).append("\n");
                    i+=2;j+=2;

                }
                else
                {
                    int v1=i,v2=j;
                    count+=5;
                    str.append(v1).append(" ").append(v2).append("\n");
                    str.append(v1+1).append(" ").append(v2).append("\n");
                    str.append(v1+1).append(" ").append(v2+1).append("\n");
                    str.append(v1+1).append(" ").append(v2+2).append("\n");
                    str.append(v1).append(" ").append(v2+2).append("\n");
                    i-=2;j+=2;
                }
            }
            ans.append(count).append("\n");
            ans.append(str.toString());

//            ans.append(7*n).append("\n");
//            int i=1,j=1;
//            for(int c=0;c<n;c++)
//            {
//                ans.append(i).append(" ").append(j).append("\n");
//                ans.append(i+1).append(" ").append(j).append("\n");
//                ans.append(i-1).append(" ").append(j).append("\n");
//                ans.append(i).append(" ").append(j+1).append("\n");
//                ans.append(i).append(" ").append(j-1).append("\n");
//                ans.append(i+1).append(" ").append(j+1).append("\n");
//                ans.append(i-1).append(" ").append(j-1).append("\n");
//
//                j+=3;
//            }

        }
        out.print(ans.toString());
        out.flush();

    }
}


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

public class C {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

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

    static FastReader s = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    private static int[] rai(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextInt();
        }
        return arr;
    }

    private static int[][] rai(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextInt();
            }
        }
        return arr;
    }

    private static long[] ral(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = s.nextLong();
        }
        return arr;
    }

    private static long[][] ral(int n, int m) {
        long[][] arr = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = s.nextLong();
            }
        }
        return arr;
    }

    private static int ri() {
        return s.nextInt();
    }

    private static long rl() {
        return s.nextLong();
    }

    private static String rs() {
        return s.next();
    }

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

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
//        int t = ri();
        int t=1;
        while (t-- > 0)
        {
            int n=ri();
            ans.append(7*n).append("\n");
            int i=1,j=1;
            for(int c=0;c<n;c++)
            {
                ans.append(i).append(" ").append(j).append("\n");
                ans.append(i+1).append(" ").append(j).append("\n");
                ans.append(i-1).append(" ").append(j).append("\n");
                ans.append(i).append(" ").append(j+1).append("\n");
                ans.append(i).append(" ").append(j-1).append("\n");
                ans.append(i+1).append(" ").append(j+1).append("\n");
                ans.append(i-1).append(" ").append(j-1).append("\n");

                j+=3;
            }

        }
        out.print(ans.toString());
        out.flush();

    }
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Ans implements Runnable {

	public static void main(String args[]) throws Exception {
		Ans s = new Ans();
		s.run();

	}

	static class Pos{
		int x; int y;

		public Pos(int x, int y){
			this.x = x;
			this.y = y;
		}

	}

	public void run() {
		InputReader sc = new InputReader(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		ArrayList<Pos> p = new ArrayList<>();
		int topx = 1;
		for(int i=-1; i<= 1; i++){
			int x = topx +i;
			for(int j = -1; j <=1;j++){
				int y = topx + j;
				if(x==y && (x == 0 || x == 2)){
					continue;
				}else{
					p.add(new Pos(x,y));
				}
			}
		}
		int k = sc.nextInt();
		int curr = 1;
		while(curr < k){
			p.add(new Pos(topx, topx+2));
			p.add(new Pos(topx+1, topx+2));
			p.add(new Pos(topx+1,topx+1));
			p.add(new Pos(topx+2, topx+1));
			p.add(new Pos(topx+2, topx));
			curr += 3;
			topx++;
		}

		pw.println(p.size());
		for(Pos c : p){
			pw.println(c.x+" "+c.y);
		}

		pw.close();

	}

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();

			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}

				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String stock = "";
			try {
				stock = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return stock;
		}

		public int nextInt() {
			int c = read();

			while (isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-') {
				sgn = -1;
				c = read();
			}

			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double nextDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next() {
			return readString();
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Ans implements Runnable {

	public static void main(String args[]) throws Exception {
		Ans s = new Ans();
		s.run();

	}

	static class Pos{
		int x; int y;

		public Pos(int x, int y){
			this.x = x;
			this.y = y;
		}

	}

	public void run() {
		InputReader sc = new InputReader(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		ArrayList<Pos> p = new ArrayList<>();
		int topx = 1;
		for(int i=-1; i<= 1; i++){
			int x = topx +i;
			for(int j = -1; j <=1;j++){
				int y = topx + j;
				if(x==y && (x == 0 || x == 2)){
					continue;
				}else{
					p.add(new Pos(x,y));
				}
			}
		}
		int k = sc.nextInt();
		int curr = 1;
		while(curr < k){
			p.add(new Pos(topx, topx+2));
			p.add(new Pos(topx+1, topx+2));
			p.add(new Pos(topx+1,topx+1));
			p.add(new Pos(topx+2, topx+1));
			p.add(new Pos(topx+2, topx));
			curr += 3;
		}

		pw.println(p.size());
		for(Pos c : p){
			pw.println(c.x+" "+c.y);
		}

		pw.close();

	}

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();

			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}

				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String stock = "";
			try {
				stock = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return stock;
		}

		public int nextInt() {
			int c = read();

			while (isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-') {
				sgn = -1;
				c = read();
			}

			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double nextDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next() {
			return readString();
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Ans implements Runnable {

	public static void main(String args[]) throws Exception {
		Ans s = new Ans();
		s.run();

	}

	public void run() {
		InputReader sc = new InputReader(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int n = sc.nextInt();
		pw.println((3*n) + 4);
		int cnt = 3;
		for(int y = 0; y <= (n+1); y++){
			cnt = (y == 0 || y == n+1) ? 2 : 3;
			int temp = max(y-1,0);
			while(cnt-- > 0){
				pw.print(temp++);
				pw.print(" ");
				pw.println(y);
			}
		}

		pw.close();

	}

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();

			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}

				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			String stock = "";
			try {
				stock = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return stock;
		}

		public int nextInt() {
			int c = read();

			while (isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-') {
				sgn = -1;
				c = read();
			}

			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double nextDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next() {
			return readString();
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}


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

public class test5 {
	public static final int mod=1000000007;
	public static void main(String[] args) throws IOException{
		BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
		//Scanner sc=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);

		int n=Integer.parseInt(sc.readLine());

		out.println(3*n+2);
		for(int i=0;i<3;i++) {
			if(i==1) {
				for(int j=0;j<=2*n;j++) {
					out.println(i+" "+j);
				}
			} else {
				for(int j=1;j<=2*n;j+=2) {
					out.println(i+" "+j);
				}
			}
		}

		out.flush();
		out.close();
	}
}


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

public class test5 {
	public static final int mod=1000000007;
	public static void main(String[] args) throws IOException{
		BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
		//Scanner sc=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);

		int n=Integer.parseInt(sc.readLine());

		out.println(3*n+4);
		out.println(0+" "+0);
		for(int i=1;i<n+2;i++) {
			out.println(i+" "+i);
			out.println(i-1+" "+i);
			out.println(i+" "+(i-1));
		}

		out.flush();
		out.close();
	}
}


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

public class test5 {
	public static final int mod=1000000007;
	public static void main(String[] args) throws IOException{
		BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
		//Scanner sc=new Scanner(System.in);
		PrintWriter out=new PrintWriter(System.out);

		int n=Integer.parseInt(sc.readLine());

		out.println(3*n+2);
		for(int i=0;i<3;i++) {
			if(i==1) {
				for(int j=0;j<=n+1;j++) {
					out.println(i+" "+j);
				}
			} else {
				for(int j=1;j<=n;j++) {
					out.println(i+" "+j);
				}
			}
		}

		out.flush();
		out.close();
	}
}


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

		 */

			//x = 0 and 2
			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 = 0; j<10000; j++) {
				pr.println(2+ " " + j); pr.println(0+" " + j);
			}
			pr.println("1 0"); pr.println("1 9999");

			for(int j = 1; j<=t; j++) {
				int num = 11*j;
				pr.println(1+" " + num);
				pr.println(-1+" " + num);
				pr.println(3+" " + num);
				pr.println(-2+" " + num);
				pr.println(4+" " + num);
				pr.println(4+" " + (num+1));
				pr.println(4+" " + (num+2));
				pr.println(-2+" " + (num+1));
				pr.println(-2+" " + (num+2));
				pr.println(-1+" " + (num+2));
				pr.println(1+" " + (num+2));
				pr.println(3+" " + (num+2));

			}
			if(rem==1) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
			}
			else if(rem==2) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
				pr.println("2 -1");pr.println("3 -1");pr.println("3 0");
			}
			else if(rem==3) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
				pr.println("2 -1");pr.println("3 -1");pr.println("3 0");
				pr.println("0 10000");pr.println("-1 10000");pr.println("-1 9999");
			}

		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 = 0 and 2
			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 = 0; j<10000; j++) {
				pr.println(2+ " " + j); pr.println(0+" " + j);
			}
			pr.println("1 0"); pr.println("1 9999");

			for(int j = 1; j<=t; j++) {
				int num = 11*j;
				pr.println(1+" " + num);
				pr.println(-1+" " + num);
				pr.println(3+" " + num);
				pr.println(-2+" " + num);
				pr.println(4+" " + num);
				pr.println(4+" " + (num+1));
				pr.println(4+" " + (num+2));
				pr.println(-2+" " + (num+1));
				pr.println(-2+" " + (num+2));
				pr.println(-1+" " + (num+2));
				pr.println(1+" " + (num+2));
				pr.println(3+" " + (num+2));

			}
			if(rem==1) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
			}
			else if(rem==2) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
				pr.println("2 -1");pr.println("3 -1");pr.println("3 0");
			}
			else if(rem==3) {
				pr.println("0 -1");pr.println("-1 -1");pr.println("-1 0");
				pr.println("2 -1");pr.println("3 -1");pr.println("3 0");
				pr.println("0 10000");pr.println("-1 10000");pr.println("-1 9999");
			}
		}
		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();
	}
}