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.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
 
 
import java.util.*;
 
public class template {
 
	InputStream is;
	PrintWriter out;
	String INPUT = "";
	
	void solve() {
		int k = ni();
		out.println("2 3");
		long a[][] = new long[2][3];
		
		a[0][0] = k+((long)1l<<17);
		a[0][1] = (long)1l<<17;
		a[0][2] = 0;
		a[1][0] = k;
		a[1][1] = k+((long)1l<<17);
		a[1][2] = k;
		
		for(long i[] : a) {
			for(long j : i) out.print(j+" ");
			out.println();
		}
		
	}
	void run() throws Exception
	{
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);
 
		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
		//tr(System.currentTimeMillis()-s+"ms");
	}
 
	public static void main(String[] args) throws Exception { new template().run(); }
	
	private void sort(int[] arr, int start, int end){
        if(start >= end) return;
        int mid = start + (end - start) / 2;
        sort(arr, start, mid);
        sort(arr, mid +1, end);
        merge(arr, start, mid, end);
    }
	private void merge(int[] arr, int start, int mid, int end){
        int i = start, j = mid + 1;
        int[] help = new int[end - start + 1];
        int c = 0;
        while(i <= mid && j <= end){
            help[c++] = arr[j] < arr[i] ? arr[j++] : arr[i++];
        }
        while(i <= mid){
            help[c++] = arr[i++];
        }
        while(j <= end){
            help[c++] = arr[j++];
        }
        for(int k = 0; k < help.length; k++){
            arr[start + k] = help[k];
        }
    }
	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;
 
	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}
 
	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
 
	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }
 
	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}
 
	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}
 
	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}
 
	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}
 
	private int[][] na(int n , int m)
	{
		int[][] a = new int[n][m];
		for(int i = 0;i < n;i++) 
			for(int j = 0 ; j<m ; j++) a[i][j] = ni();
		return a;
	}
 
	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}
 
		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}
 
	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}
 
		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}
 
	void display2D(int a[][]) {
		for(int i[] : a) {
			for(int j : i) {
				out.print(j+" ");
			}
			out.println();
		}
	}
 
	int[][] creategraph(int n , int m) {
		int g[][] = new int[n+1][];
 
		int from[] = new int[m];
		int to[] = new int[m];
		int ct[] = new int[n+1];
 
		for(int i = 0 ; i<m; i++) {
			from[i] = ni();
			to[i] = ni();
			ct[from[i]]++;
			ct[to[i]]++;
		}
 
		int parent[] = new int[n+1];
 
		for(int i = 0 ; i<n+1 ; i++) g[i] = new int[ct[i]];
 
		for(int i = 0 ; i<m ; i++) {
			g[from[i]][--ct[from[i]]] = to[i];
			g[to[i]][--ct[to[i]]] = from[i];
		}
 
		return g;
	}
 
	static long __gcd(long a, long b)
	{
 
		if(b == 0) 
		{
			return a;
		}
		else
		{
			return __gcd(b, a % b);
		}
	}
 
	// To compute x^y under modulo m
	static long power(long x, long y, long p)
	{
 
		// Initialize result
		long res = 1;
 
		// Update x if it is more than or
		// equal to p
		x = x % p;
 
		while (y > 0)
		{
 
			// If y is odd, multiply x
			// with result
			if (y % 2 == 1)
				res = (res * x) % p;
 
			// y must be even now
			y = y >> 1; // y = y/2
		x = (x * x) % p;
		}
 
		return res;
	}
 
	// Function to find modular 
	// inverse of a under modulo m
	// Assumption: m is prime
	static long modInverse(long a, int m)
	{
		if (__gcd(a, m) != 1) {
			//System.out.print("Inverse doesn't exist");
			return -1;
		}
 
		else {
 
			// If a and m are relatively prime, then
			// modulo inverse is a^(m-2) mode m
			//			System.out.println("Modular multiplicative inverse is "
			//											+power(a, m - 2, m));
			return power(a, m - 2, m);
		}
	}
 
	static long nCrModPFermat(int n, int r,
			int p , long fac[])
	{
 
		// Base case
		if (r == 0)
			return 1;
 
		// Fill factorial array so that we
		// can find all factorial of r, n
		// and n-r
		long t = (fac[n]* modInverse(fac[r], p))%p;
 
		return ( (t* modInverse(fac[n-r], p))% p);
	}
 
 
	private static void tr(Object... o) { System.out.println(Arrays.deepToString(o)); }
}