Problem: You are given an array a of n integers.

You want to make all elements of a equal to zero by doing the following operation exactly three times:

  * Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different). 



It can be proven that it is always possible to make all elements of a equal to zero.

Input

The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.

The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).

Output

The output should contain six lines representing three operations.

For each operation, print two lines:

  * The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.

  * The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.

Example

Input


4
1 3 2 4


Output


1 1 
-1
3 4
4 2
2 4
-3 -6 -6

Solution (in JAVA):

Solution:
// Don't place your source in a package
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*; 
// Please name your class Main
public class Main {
	
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    
 
    static int read() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static String readString() throws IOException {
        in.nextToken();
        return in.sval;
	}
	
	
	public static void main (String[] args) throws java.lang.Exception {
	    Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		//InputReader in = new InputReader(System.in);
		int T =1;
		for(int t=0;t<T;t++){
			int n=in.nextInt();
			long A[]=new long[n];
			for(int i=0;i<n;i++){
				A[i]=in.nextLong();
			}
			Solution s=new Solution();
			s.solution(A,out);
			out.flush();
		}
		
		
		
		
		//for(int t=0;t<T;t++){
		//int C,L;
		/*while((N = read()) != 0){
			M=read();
			if(N==0&&M==0)break;
			
			List<Integer>adjecent[]=new ArrayList[N];
			for(int i=0;i<N;i++){
				//if(adjecent[i]!=null)adjecent[i].celar();
				 adjecent[i]=new ArrayList<Integer>();
			}
			
			for(int i=0;i<M;i++){
				int v1=read();int v2=read();
				adjecent[v1].add(v2);
				adjecent[v2].add(v1);
			}
			
			Solution s=new Solution();
			s.solution(adjecent,out);
		}*/
		
		/*int A[][]=new int[4][4];
		for(int i=0;i<4;i++){
			String s=in.next();
			for(int j=0;j<s.length();j++){
				if(s.charAt(j)=='b'){
					A[i][j]=0;
				}else{
					A[i][j]=1;
				}
			}
		}*/
		
				
				//out.flush();
		
		}
 
}
 
class Solution{
	//constant variable
	final int MAX=Integer.MAX_VALUE;
	final int MIN=Integer.MIN_VALUE;
	List<Integer>adjecent[];
	//////////////////////////////

	
	public void solution(long A[],PrintWriter out){
		int len=A.length;
		if(A.length==1){
			out.println((len)+" "+len);
			out.println((0)+"");
			out.println((len)+" "+len);
			out.println((0)+"");
			out.println((len)+" "+len);
			out.println((-A[len-1])+"");
			return;
		}
		
		
		
		long res[][]=new long[A.length][2];
		
		for(int i=0;i<A.length-1;i++){
			long x=len;
			long cur=A[i];
			long c=cur+x;
			long b=1-c;
			res[i][0]=x*b;
			res[i][1]=(x-1)*c;
		}
		
		
		
		
		out.println(1+" "+len);
		for(int i=0;i<len;i++){
			out.print(res[i][0]+" ");
		}out.println();
		
		out.println(1+" "+(len-1));
		for(int i=0;i<len-1;i++){
			out.print(res[i][1]+" ");
		}out.println();
		
		//last line
		out.println((len)+" "+len);
		out.println((-A[len-1])+"");
	}
	

	

	
	


	/*public void tarjan(int p,int r){
		if(cut)return;
		List<Integer>childs=adjecent[r];
		dis[r]=low[r]=time;
		time++;
		
		//core for tarjan
		int son=0;
		for(int c:childs){
			if(ban==c||c==p)continue;
			if(dis[c]==-1){
				son++;
				tarjan(r,c);
				low[r]=Math.min(low[r],low[c]);
				if((r==root&&son>1)||(low[c]>=dis[r]&&r!=root)){
					cut=true;
					return;
				}
			}else{
				if(c!=p){
					low[r]=Math.min(low[r],dis[c]);
				}
			}
		}
		
	}*/
	
	

	
	
		
	
	//helper function I would use
	public int flip(int i){
		if(i==0)return 1;
		else return 0;
	}
	
	public boolean[] primes(int n){
		boolean A[]=new boolean[n+1];
		for(int i=2;i<=n;i++){
			if(A[i]==false){
				for(int j=i+i;j<=n;j+=i){
					A[j]=true;
				}
			}
		}
		return A;
	}
	
	public void msg(String s){
		System.out.println(s);
	}
	
	public int[] kmpPre(String p){
		int pre[]=new int[p.length()];
		int l=0,r=1;
		while(r<p.length()){
			if(p.charAt(l)==p.charAt(r)){
				pre[r]=l+1;
				l++;r++;
			}else{
				if(l==0)r++;
				else l=pre[l-1];
			}
		}
		return pre;
	}
	
	public boolean isP(String s){
		int l=0,r=s.length()-1;
		while(l<r){
			if(s.charAt(l)!=s.charAt(r))return false;
			l++;r--;
		}
		return true;
	}
	
	public int find(int nums[],int x){//union find => find method
		if(nums[x]==x)return x;
		int root=find(nums,nums[x]);
		nums[x]=root;
		return root;
	}
	
	public boolean check(int grid[][],int r,int c){
		if(r<0||c<0||r>=grid.length||c>=grid[0].length)return false;
		return true;
	}
	
	public int get(int A[],int i){
		if(i<0||i>=A.length)return -1;
		return A[i];
	}
	public int[] copy(int A[]){
		int a[]=new int[A.length];
		for(int i=0;i<a.length;i++)a[i]=A[i];
		return a;
	}
	public void print1(long A[]){
		for(long i:A)System.out.print(i+" ");
		System.out.println();
	}
	public void print2(long 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();
		}
	}
	
	public int min(int a,int b){
		return Math.min(a,b);
	}
}

	class Wrapper implements Comparable<Wrapper>{
		int spf;int cnt;
		public Wrapper(int spf,int cnt){
			this.spf=spf;
			this.cnt=cnt;
		}
		
		@Override
		public int compareTo(Wrapper other) {
			return this.spf-other.spf;
		}
	}