Bob is playing a game named "Walk on Matrix".

In this game, player is given an n × m matrix A=(a_{i,j}), i.e. the element in the i-th row in the j-th column is a_{i,j}. Initially, player is located at position (1,1) with score a_{1,1}. 

To reach the goal, position (n,m), player can move right or down, i.e. move from (x,y) to (x,y+1) or (x+1,y), as long as player is still on the matrix.

However, each move changes player's score to the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of the current score and the value at the position he moves to.

Bob can't wait to find out the maximum score he can get using the tool he recently learnt — dynamic programming. Here is his algorithm for this problem. 

<image>

However, he suddenly realize that the algorithm above fails to output the maximum score for some matrix A. Thus, for any given non-negative integer k, he wants to find out an n × m matrix A=(a_{i,j}) such that 

  * 1 ≤ n,m ≤ 500 (as Bob hates large matrix); 
  * 0 ≤ a_{i,j} ≤ 3 ⋅ 10^5 for all 1 ≤ i≤ n,1 ≤ j≤ m (as Bob hates large numbers); 
  * the difference between the maximum score he can get and the output of his algorithm is exactly k. 



It can be shown that for any given integer k such that 0 ≤ k ≤ 10^5, there exists a matrix satisfying the above constraints.

Please help him with it!

Input

The only line of the input contains one single integer k (0 ≤ k ≤ 10^5).

Output

Output two integers n, m (1 ≤ n,m ≤ 500) in the first line, representing the size of the matrix. 

Then output n lines with m integers in each line, a_{i,j} in the (i+1)-th row, j-th column.

Examples

Input


0


Output


1 1
300000

Input


1


Output


3 4
7 3 3 1
4 8 3 6
7 7 7 3

Note

In the first example, the maximum score Bob can achieve is 300000, while the output of his algorithm is 300000.

In the second example, the maximum score Bob can achieve is 7\&3\&3\&3\&7\&3=3, while the output of his algorithm is 2.

import java.util.*;
import java.io.*;
public class Main {
    static FastReader in=new FastReader();
    static StringBuilder Sd=new StringBuilder();
    static List<Integer>Gr[]; 
    static int a[],b[];
    static boolean visit[];
    public static void main(String [] args) {
    	//Dir by MohammedElkady
    	int t=1;
    	while(t-->0) {
        int k=in.nextInt();
        if(k==0) {
        	Soutln("1 1");
        	Soutln("20");
        }
        else {
        	Soutln("2 3");
        	int a[][]=new int[2][3];
        	int max=0,lole=0,x=1,sum=0;
        	for(int i=0;i<25;i++) {
        		sum+=x;
        		if(x>k) {
        		
        			lole=x;
        			a[0][2]=lole;
        			a[0][0]=(lole*2)|lole|k;
        			a[1][1]=(lole*2)|lole|k;
        			a[1][0]=(lole*2);
        			a[0][1]=lole|k;
        			a[1][2]=lole|k;
        			if(a[0][0]<=300000&&k>10) {
        			Soutln(a[0][0]+" "+a[0][1]+" "+a[0][2]);
        			Soutln(a[1][0]+" "+a[1][1]+" "+a[1][2]);
        			}
        			else {
        				a[0][0]=sum;
        				a[1][1]=sum;
        				a[0][1]=sum-x;
        				a[0][2]=sum-x-k;
        				a[1][0]=x;
        				a[1][2]=sum-x;

            			Soutln(a[0][0]+" "+a[0][1]+" "+a[0][2]);
            			Soutln(a[1][0]+" "+a[1][1]+" "+a[1][2]);
        			}
        			break;}
        		x*=2;
        	}
        }
        
    	}
    Sclose();
    
}
   
    static long gcd(long g,long x){
        if(x<1)return g;
        else return gcd(x,g%x);
    }
    //array fill
    static long[]filllong(int n){long a[]=new long[n];for(int i=0;i<n;i++)a[i]=in.nextLong();return a;}
    static int[]fillint(int n){int a[]=new int[n];for(int i=0;i<n;i++)a[i]=in.nextInt();return a;}
    //OutPut Line
    static void Sout(String S) {Sd.append(S);}
    static void Soutln(String S) {Sd.append(S+"\n");}
    static void Soutf(String S) {Sd.insert(0, S);}
    static void Sclose() {System.out.println(Sd);}
    static void Sclean() {Sd=new StringBuilder();}
}
 class tosolve{
	 ArrayList<node>no=new ArrayList();
	 void sort() {
		 Collections.sort(no);
	 }
    void add(node o) {
    	no.add(o);
    }
 }
class node implements Comparable<node>{
int l,r;
	node(int x,int p){
		this.l=x;
		this.r=p;
	}
	@Override
	public int compareTo(node o) {
       return (l-o.l);
	}
}
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;
        }
}
 
class Sorting{
 
 public static int[] bucketSort(int[] array, int bucketCount) {
 
 if (bucketCount <= 0) throw new IllegalArgumentException("Invalid bucket count");
 
 if (array.length <= 1) return array; //trivially sorted
 
 
 
 int high = array[0];
 
 int low = array[0];
 
 for (int i = 1; i < array.length; i++) { //find the range of input elements
 
 if (array[i] > high) high = array[i];
 
 if (array[i] < low) low = array[i];
 
 }
 
 double interval = ((double)(high - low + 1))/bucketCount; //range of one bucket
 
 
 ArrayList<Integer> buckets[] = new ArrayList[bucketCount];
 
 for (int i = 0; i < bucketCount; i++) { //initialize buckets
 
 buckets[i] = new ArrayList();
 
 }
 
 
 
 for (int i = 0; i < array.length; i++) { //partition the input array
 
 buckets[(int)((array[i] - low)/interval)].add(array[i]);
 
 }
 
 
 int pointer = 0;
 
 for (int i = 0; i < buckets.length; i++) {
 
 Collections.sort(buckets[i]); //mergeSort
 
 for (int j = 0; j < buckets[i].size(); j++) { //merge the buckets
 
 array[pointer] = buckets[i].get(j);
 
 pointer++;
 
 }
 
}
 
return array;
 
}
}