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

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Greedy algorithms

Number theory

Constructive algorithms


Solutions:
from sys import stdin

def inp():
	return stdin.buffer.readline().rstrip().decode('utf8')

def itg():
	return int(stdin.buffer.readline())

def mpint():
	return map(int, stdin.buffer.readline().split())
n = itg()
if n == 1:
	print('1 1')
	print(-itg())
	print('1 1')
	print('0')
	print('1 1')
	print('0')
	exit()
arr = list(mpint())
print(1, n - 1)
print(*map(lambda x: x * (n - 1), arr[:-1]))
print(2, n)
print(*[0] * (n - 2) + [arr[-1] * (n - 1)])
print(1, n)
print(*map(lambda x: -x * n, arr))


n = int(input())
a = [int(x) for x in input().split()]
if n > 1:
	print('1 1')
	print(-a[0])
	print('2 ' + str(n))
	for i in range(1, n):
		print((n - 1) * a[i], end=' ')
	print('')
	print('1 ' + str(n))
	print('0', end=' ')
	for i in range(1, n):
		print(-(a[i] + (n - 1) * a[i]), end=' ')
else:
	print('1 1')
	print(-a[0])
	print('1 1')
	print(0)
	print('1 1')
	print(0)


from collections import Counter
from typing import *
(n, a) = (int(input()), [int(x) for x in input().split()])
if n == 1:
	print('1 1\n0')
	print('1 1\n0')
	print('1 1\n{}'.format(-a[0]))
else:
	print('1 {}'.format(n - 1))
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
		a[i] *= n
	print('')
	print('{} {}\n{}'.format(n, n, a[n - 1] * (n - 1)))
	a[n - 1] *= n
	print('1 {}'.format(n))
	for i in range(n):
		print(-a[i], end=' ')


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print('1 1', -a[0], '1 1', '0', '1 1', '0', sep='\n')
	exit(0)
print(1, n)
for i in range(n):
	print(-a[i] * n, end=' ')
	a[i] -= a[i] * n
print()
print(1, n - 1)
for i in range(n - 1):
	print(-a[i], end=' ')
	a[i] = 0
print()
print(2, n)
for i in range(1, n):
	print(-a[i], end=' ')
	a[i] = 0
print()


import sys
import math, bisect
sys.setrecursionlimit(10 ** 5)
from collections import defaultdict
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, OrderedDict

def I():
	return int(sys.stdin.readline())

def neo():
	return map(int, sys.stdin.readline().split())

def Neo():
	return list(map(int, sys.stdin.readline().split()))
n = I()
l = Neo()
if n == 1:
	s = '1 1\n' + str(-l[0]) + '\n1 1\n0\n1 1\n0'
	print(s)
else:
	(a, an) = ([], [])
	for i in range(n):
		an.append(-l[i] * n)
	b = -(l[0] + an[0])
	for i in range(1, n):
		a.append(l[i] * (n - 1))
	print(1, n)
	print(*an)
	print(1, 1)
	print(b)
	print(2, n)
	print(*a)


def tc():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(-a[0])
		for _ in range(2):
			print(1, 1)
			print(0)
		return
	first = []
	for (i, x) in enumerate(a[:-1]):
		rem = x % n
		if rem <= n // 2:
			delta = rem * (n - 1)
		else:
			delta = -(n - rem) * (n - 1)
		a[i] += delta
		first.append(delta)
	print(1, n - 1)
	print(' '.join(map(str, first)))
	print(n, n)
	print(-a[-1])
	third = []
	for x in a[:-1]:
		third.append(-x)
	third.append(0)
	print(1, n)
	print(' '.join(map(str, third)))
tc()


N = int(input())
A = list(map(int, input().split()))
B = []
print(1, 1)
print((N - 1) * A[0])
B.append(A[0] + abs(N - A[0]))
if N >= 2:
	print(2, N)
	print(' '.join(map(str, [v * (N - 1) for v in A[1:]])))
	for v in A[1:]:
		B.append(v + v * (N - 1) * (N - 1))
else:
	print(1, 1)
	print(0)
print(1, N)
print(' '.join(map(str, [-v * N for v in A])))


import sys
ll = lambda : list(map(int, input().split()))
lls = lambda : list(map(str, input().split()))
fin = lambda : list(map(float, input().split()))
st = lambda : input()
v = lambda : map(int, input().split())
ii = lambda : int(input())
mod = 10 ** 9 + 7
from math import *
from datetime import datetime
from collections import *
import math
x = ii()
l = ll()
if x < 3:
	if x == 1:
		print(1, 1)
		l[0] += 1
		print(1)
		print(1, 1)
		l[0] += 1
		print(1)
		print(1, 1)
		print(-l[0])
	else:
		print(1, 1)
		print(-l[0])
		if l[1] % 2:
			print(2, 2)
			print(1)
			l[1] += 1
			print(2, 2)
			print(-l[1])
		else:
			print(2, 2)
			print(0)
			print(2, 2)
			print(-l[1])
elif x == 3:
	print(1, 1)
	print(-l[0])
	print(2, 2)
	print(-l[1])
	print(3, 3)
	print(-l[2])
else:
	print(x, x)
	print(-l[-1])
	l[-1] = 0
	print(1, x - 1)
	sol = []
	for i in range(x - 1):
		sol.append((x - 1) * ((l[i] % x + x) % x))
		l[i] += sol[i]
	print(*sol)
	print(1, x)
	ans = []
	for i in range(x):
		ans.append(-l[i])
	print(*ans)


import sys
input = sys.stdin.readline

def solution():
	N = int(input())
	A = list(map(int, input().split()))
	if N == 1:
		print(1, 1)
		print(-A[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return
	print(1, N - 1)
	for i in range(N - 1):
		print((N - 1) * A[i], end=' ')
		A[i] += (N - 1) * A[i]
	print()
	print(N, N)
	print(-A[-1])
	A[-1] = 0
	print(1, N)
	for i in range(N):
		print(-A[i], end=' ')
	print()
solution()


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-arr[-1])
else:
	print(1, 1)
	print(-1 * arr[0])
	print(2, n)
	for i in range(1, n):
		val = arr[i] % n * (n - 1)
		print(val, end=' ')
		arr[i] += val
	print()
	print(1, n)
	for i in range(n):
		if i == 0:
			print(0, end=' ')
			continue
		print(-1 * arr[i], end=' ')


import math
n = int(input())
a = list(map(int, input().split()))
if n < 3:
	if n == 1:
		print(1, 1)
		print(-1 * a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
	else:
		print(1, 1)
		print(-1 * a[0])
		print(2, 2)
		print(-1 * a[1])
		print(1, 2)
		print(0, 0)
else:
	print(1, n - 1)
	for i in range(n - 1):
		x = a[i] % n
		a[i] += x * (n - 1)
		print(x * (n - 1), end=' ')
	print()
	print(2, n)
	for i in range(1, n):
		x = a[i] % n
		a[i] += x * (n - 1)
		print(x * (n - 1), end=' ')
	print()
	print(1, n)
	for i in range(n):
		print(-1 * a[i], end=' ')
	print()


import math

def main():
	n = int(input())
	lst = list(map(int, input().split()))
	line1 = '1 ' + str(n) + '\n0 '
	line2 = '2 ' + str(n) + '\n'
	line3 = '1 1\n' + str(-lst[0])
	for i in range(1, n):
		if lst[i] % (n - 1) != 0:
			line1 += str(-n * (lst[i] % (n - 1)))
			lst[i] -= n * (lst[i] % (n - 1))
		else:
			line1 += '0'
		line1 += ' '
	for i in range(1, n):
		line2 += str(-lst[i]) + ' '
	if n > 1:
		print(line1)
		print(line2)
	else:
		print('1 1\n0\n1 1\n0')
	print(line3)
t = 1
for i in range(t):
	main()


n = int(input())
a = list(map(int, input().split()))
print(f'1 {n}')
for i in a:
	print(-i * n, end=' ')
if n == 1:
	print('')
	for i in range(2):
		print('1 1')
		print('0')
else:
	print(f'\n1 {n - 1}')
	for i in a[:-1]:
		print(i * (n - 1), end=' ')
	print(f'\n2 {n}')
	for i in range(n - 2):
		print('0', end=' ')
	print(a[-1] * (n - 1))


n = int(input())
a = list(map(int, input().split()))
l = a[-1]
if n > 1:
	print(1, n - 1)
	print(*[(n - 1) * i for i in a[:n - 1]])
else:
	print(1, 1)
	print(0)
print(n, n)
print(-l)
print(1, n)
print(*[-n * i for i in a[:-1]] + [0])


from collections import Counter
for i in range(1):
	n = int(input())
	if n > 1:
		a = [int(X) for X in input().split()]
		print(1, n)
		print(*[-1 * a[i] * n for i in range(n)])
		print(1, n - 1)
		print(*[(n - 1) * a[i] for i in range(n - 1)])
		print(n, n)
		print((n - 1) * a[-1])
	else:
		print(1, 1)
		print(-1 * int(input()))
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)


import sys
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
	return int(buff_readline())

def read_int_n():
	return list(map(int, buff_readline().split()))

def read_float():
	return float(buff_readline())

def read_float_n():
	return list(map(float, buff_readline().split()))

def read_str():
	return readline().strip()

def read_str_n():
	return readline().strip().split()

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

def divisor(n):
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			yield i
			if i != n // i:
				yield (n // i)

@mt
def slv(N, A):
	if N == 1:
		print(1, 1)
		print(-A[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return
	a = A[:]
	na = a[:]
	error_print([-na[i] % N for i in range(N)])
	for i in range(N - 1):
		if a[i] > 0:
			na[i] = a[i] + a[i] % N * (N - 1)
		else:
			na[i] = a[i] - (N - a[i] % N) * (N - 1)
	print(1, N - 1)
	print(*[na[i] - a[i] for i in range(N - 1)])
	a = na[:]
	for i in range(N - 1, N):
		if a[i] > 0:
			na[i] = a[i] - a[i] % N
		else:
			na[i] = a[i] - a[i] % N
	print(N, N)
	print(*[na[i] - a[i] for i in range(N - 1, N)])
	print(1, N)
	print(*[-na[i] for i in range(N)])
	error_print(na)
	error_print([-na[i] % N for i in range(N)])

def main():
	N = read_int()
	A = read_int_n()
	slv(N, A)
main()


n = int(input())
a = [int(i) for i in input().split()]
if n > 1:
	print(1, n - 1)
	for i in range(0, n - 1):
		z = a[i] % n * (n - 1)
		a[i] += z
		print(z, end=' ')
	print()
	print(n, n)
	print(-a[n - 1])
	a[n - 1] = 0
	print(1, n)
	for i in range(n):
		print(-a[i], end=' ')
else:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)


n = int(input())
a = list(map(int, input().split()))
print('1 1\n' + str((n - 1) * a[0]))
if n >= 2:
	print(2, n)
	print(*[(n - 1) * a[i] for i in range(1, n)])
else:
	print('1 1\n0')
print(1, n)
print(*[-n * a[i] for i in range(n)])


n = int(input())
arr = list(map(int, input().split()))
if n > 1:
	l1 = []
	for i in range(n - 1):
		l1.append(arr[i] % n * (n - 1))
	print(1, n - 1)
	print(*l1)
	print(n, n)
	print(-(arr[-1] % n))
	print(1, n)
	l2 = []
	for i in range(n):
		if i < n - 1:
			val = arr[i] + l1[i]
		else:
			val = arr[i] - arr[-1] % n
		l2.append(val * -1)
	print(*l2)
else:
	print(1, 1)
	print(-arr[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return
	print(1, n - 1)
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
		a[i] += a[i] * (n - 1)
	print()
	print(1, n)
	for i in range(n):
		print(-n * (a[i] // n), end=' ')
		a[i] -= n * (a[i] // n)
	print()
	print(n, n)
	print(-a[-1])
for _ in range(1):
	solve()


n = int(input())
A = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-A[0])
	exit()
if A[-1] != n:
	print(n, n)
	print(n - A[-1])
	A[-1] = n
	print(1, n - 1)
	res = []
	for i in range(n - 1):
		res.append((n - 1) * A[i])
	print(*res)
	print(1, n)
	res = []
	for i in range(n - 1):
		res.append(-n * A[i])
	res.append(-A[-1])
	print(*res)
else:
	print(1, 1)
	print(0)
	print(1, n - 1)
	res = []
	for i in range(n - 1):
		res.append((n - 1) * A[i])
	print(*res)
	print(1, n)
	res = []
	for i in range(n - 1):
		res.append(-n * A[i])
	res.append(-A[-1])
	print(*res)


n = int(input())
seq = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-seq[0])
	print(1, 1)
	print(-seq[0])
	print(1, 1)
	print(seq[0])
else:
	print(1, 1)
	print(-(seq[0] - n))
	print(2, n)
	print(*[(n - 1) * seq[i] for i in range(1, n)])
	tmp = [-n * seq[i] for i in range(0, n)]
	tmp[0] = -n
	print(1, n)
	print(*tmp)


n = int(input())
li = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-li[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n)
	for i in range(n):
		if li[i] >= 0:
			print(n * -li[i], end=' ')
		else:
			print(n * abs(li[i]), end=' ')
	print()
	print(1, n - 1)
	for i in range(n - 1):
		if li[i] >= 0:
			print((n - 1) * li[i], end=' ')
		else:
			print((n - 1) * li[i], end=' ')
	print()
	print(2, n)
	for i in range(1, n):
		if i != n - 1:
			print(0, end=' ')
		elif li[i] >= 0:
			print((n - 1) * li[i], end=' ')
		else:
			print((n - 1) * li[i], end=' ')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
from math import floor
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
n = int(ri())
a = Ri()
if n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	ans = []
	na = [0] * n
	na[0] = 0
	g = (n - 1) * n
	ans.append((1, 1))
	ans.append([-a[0]])
	ans.append((2, n))
	temp = []
	for i in range(1, n):
		rem = a[i] % n
		rem = n - rem
		na[i] = a[i] + (n - 1) * (n - rem)
		temp.append(na[i] - a[i])
	ans.append(temp)
	ans.append((1, n))
	temp = []
	for i in range(0, n):
		temp.append(-na[i])
	ans.append(temp)
	for i in ans:
		print(*i)


n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-l[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(2, n)
	for i in range(1, n):
		print((n - 1) * l[i], end=' ')
	print()
	print(1, n)
	for i in range(n):
		if i != 0:
			print(-n * l[i], end=' ')
		else:
			print(0, end=' ')
	print()
	print(1, 1)
	print(-l[0])


import sys
import math
input = sys.stdin.readline

def gcd(a, b):
	if a == 0 or b == 0:
		return a + b
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def nsk(a, b):
	return a * b // gcd(a, b)
N = int(input())
A = list(map(int, input().split(' ')))
if N == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-A[0])
	exit(0)
X = nsk(N, N - 1)
print(1, N - 1)
add = [A[i] % N * (N - 1) for i in range(N - 1)]
print(' '.join(map(str, add)))
for i in range(N - 1):
	A[i] += add[i]
print(N, N)
print(X - A[N - 1])
A[N - 1] = X
print(1, N)
print(' '.join(map(str, (-a for a in A))))


import sys
inp = sys.stdin.buffer.readline
inar = lambda : list(map(int, inp().split()))
inin = lambda : int(inp())
inst = lambda : inp().decode().strip()
_T_ = 1
for _t_ in range(_T_):
	n = inin()
	a = inar()
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		break
	print(n, n)
	print(-a[-1])
	a[-1] -= a[-1]
	print(1, n - 1)
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
		a[i] += a[i] * (n - 1)
	print()
	print(1, n)
	for i in range(n):
		print(-a[i], end=' ')
		a[i] -= a[i]
	print()


from collections import Counter
import string
import math
import sys
from fractions import Fraction

def array_int():
	return [int(i) for i in sys.stdin.readline().split()]

def vary(arrber_of_variables):
	if arrber_of_variables == 1:
		return int(sys.stdin.readline())
	if arrber_of_variables >= 2:
		return map(int, sys.stdin.readline().split())

def makedict(var):
	return dict(Counter(var))
testcases = 1
for _ in range(testcases):
	n = vary(1)
	num = array_int()
	if n == 1:
		print(1, 1)
		print(-1 * num[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
	else:
		print(1, 1)
		print(-1 * num[0])
		print(1, n)
		print(0, end=' ')
		for i in range(1, n):
			print(-1 * n * num[i], end=' ')
		print()
		print(2, n)
		for i in range(1, n):
			print((n - 1) * num[i], end=' ')
		print()


n = int(input())
A = list(map(int, input().split()))
X = [-n * i for i in A]
print('1 {}'.format(str(n)))
print(*X)
if n > 1:
	Y = [(n - 1) * i for i in A[1:]]
	print('2 {}'.format(str(n)))
	print(*Y)
	print('1 1')
	print(str((n - 1) * A[0]))
else:
	print('1 1')
	print(0)
	print('1 1')
	print(0)


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, 1)
	print(-a[0])
	a[0] = 0
	print(2, len(a))
	lenc = len(a) - 1
	for i in range(1, n):
		val = a[i] % n * lenc
		a[i] += val
		print(val, end=' ')
	print(1, n)
	for i in range(len(a)):
		print(-a[i], end=' ')


t = 1
for _ in range(t):
	n = int(input())
	listi = list(map(int, input().split()))
	print(1, 1)
	print((n - 1) * listi[0])
	if n >= 2:
		print(2, n)
		for i in range(1, n):
			print((n - 1) * listi[i], end=' ')
		print()
	else:
		print(1, 1)
		print(0)
	print(1, n)
	for i in range(n):
		print(-n * listi[i], end=' ')


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
import math
import heapq
i_m = 9223372036854775807

def inin():
	return int(input())

def stin():
	return input()

def spin():
	return map(int, stin().split())

def lin():
	return list(map(int, stin().split()))

def matrix(n):
	return [list(map(int, input().split())) for i in range(n)]

def string2intlist(s):
	return list(map(int, s))

def calculate_sum(a, N):
	m = N / a
	sum = m * (m + 1) / 2
	ans = a * sum
	return ans

def series(N):
	return N * (N + 1) // 2

def count2Dmatrix(i, list):
	return sum((c.count(i) for c in list))

def modinv(n, p):
	return pow(n, p - 2, p)

def GCD(x, y):
	x = abs(x)
	y = abs(y)
	if min(x, y) == 0:
		return max(x, y)
	while y:
		(x, y) = (y, x % y)
	return x

def LCM(x, y):
	return x * y // GCD(x, y)

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def isprime(n):
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			return False
	return True
prime = []

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j
n = inin()
l = lin()
if n == 1:
	print(1, 1)
	print(-l[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n)
	print(' '.join([str(-n * i) for i in l]))
	print(1, n - 1)
	print(' '.join([str((n - 1) * i) for i in l[:n - 1]]))
	print(2, n)
	print(' '.join([str(0) for i in range(n - 2)] + [str((n - 1) * l[-1])]))


def fun(ai, n):
	ii = -ai % n
	num = ii * n - ii - ai
	return num
n = int(input())
a = [int(i) for i in input().split()]
if n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	ans1 = []
	for i in range(n):
		if a[i] % n == 0:
			ans1.append(-a[i])
			a[i] = 0
		else:
			ans1.append(fun(a[i], n))
			a[i] += ans1[-1]
	ans2 = []
	for i in range(n - 1):
		ans2.append(-a[i])
	print(1, n)
	print(*ans1)
	print(1, n - 1)
	print(*ans2)
	print(n, n)
	print(-a[-1])


from collections import defaultdict as dc
import math
import sys
input = sys.stdin.readline
n = int(input())
l = list(map(int, input().split()))
if n > 1:
	p = [0] * n
	q = [0] * (n - 1)
	r = [0] * 1
	for i in range(n - 1):
		p[i] = -1 * l[i] * n
		q[i] = l[i] * (n - 1)
	r[0] = -l[n - 1] - n
	p[n - 1] = n
	print(1, n - 1)
	for i in range(n - 2):
		print(q[i], end=' ')
	print(q[-1])
	print(1, n)
	for i in range(n - 1):
		print(p[i], end=' ')
	print(p[-1])
	print(n, n)
	print(r[0])
else:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-l[0])


import math
import os
import random
import re
import sys
from collections import defaultdict, Counter, deque
import heapq
from functools import lru_cache
from itertools import accumulate, chain, combinations, permutations, groupby, zip_longest
from math import floor, ceil, sqrt
L = int(input())
arr = list(map(int, input().split()))
if len(arr) == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-arr[0])
else:
	print(' '.join(map(str, [1, L - 1])))
	add = [arr[i] % L * (L - 1) for i in range(L - 1)]
	print(' '.join(map(str, add)))
	for i in range(L - 1):
		arr[i] += add[i]
	print(' '.join(map(str, [L, L])))
	print(-1 * (arr[-1] % L))
	arr[-1] += -1 * (arr[-1] % L)
	print(' '.join(map(str, [1, L])))
	print(' '.join(map(str, [-v for v in arr])))


from sys import stdin, stdout

def update(l, b, a):
	for i in range(len(b)):
		a[i + l - 1] += b[i]

def disp(l, r, b):
	stdout.write('{0} {1}\n'.format(l, r))
	stdout.write(' '.join([str(i) for i in b]))
	stdout.write('\n')

def main():
	n = int(stdin.readline())
	a = [int(i) for i in stdin.readline().split()]
	if n != 1:
		(l, r) = (1, 1)
		b = [0] * (r - l + 1)
		b[0] = n - a[0]
		update(l, b, a)
		disp(l, r, b)
		(l, r) = (2, n)
		b = [0] * (r - l + 1)
		length = n - 1
		for i in range(l - 1, r):
			v = a[i] % n
			v2 = length * v
			b[i - l + 1] = v2
		update(l, b, a)
		disp(l, r, b)
		(l, r) = (1, n)
		b = [0] * (r - l + 1)
		for i in range(n):
			b[i] = -a[i]
		update(l, b, a)
		disp(l, r, b)
	else:
		(l, r) = (1, 1)
		b = [-a[0]]
		update(l, b, a)
		disp(l, r, b)
		b = [0]
		update(l, b, a)
		disp(l, r, b)
		b = [0]
		update(l, b, a)
		disp(l, r, b)
main()


n = int(input())
xs = [int(x) for x in input().split()]
ans = []
for i in range(len(xs) - 1):
	c = (n - 1) * xs[i]
	ans.append(c)
if n == 1:
	print(1, 1)
	print(0)
else:
	print(1, n - 1)
	print(' '.join((str(x) for x in ans)))
print(n, n)
print((n - 1) * xs[-1])
print(1, n)
ans = []
for x in xs:
	c = -n * x
	ans.append(c)
print(' '.join((str(x) for x in ans)))


from sys import stdin, stdout
n = int(stdin.readline())
l = list(map(int, stdin.readline().split()))
if n == 1:
	stdout.write(f'1 1\n{-l[0]}\n1 1\n0\n1 1\n0')
else:
	stdout.write(f'1 1\n{-l[0]}\n2 {n}\n')
	for i in range(1, n):
		x = l[i] % n
		stdout.write(str(x * (n - 1)) + ' ')
		l[i] += x * (n - 1)
	stdout.write(f'\n1 {n}\n0')
	for i in range(1, n):
		stdout.write(f' {-l[i]}')


def solve(number, len):
	x = len - number
	if (number + x * (len - 1)) % len == 0:
		return x
	else:
		x = len + number
		return x
LEN = int(input())
arr = list(map(int, input().split()))
if LEN != 1:
	y = arr[-1]
	arr = arr[:-1]
	m = LEN - 1
	print(1, m)
	new_arr = []
	for i in arr:
		x = solve(i, LEN)
		new_arr.append(x * (LEN - 1) + i)
		print(x * (LEN - 1), end=' ')
	print()
	print(LEN, LEN)
	print(-(y % LEN))
	y = y - y % LEN
	print(1, LEN)
	for i in new_arr:
		print(-i, end=' ')
	print(-y)
else:
	print(1, 1)
	print(-arr[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)


n = int(input())
a = [int(s) for s in input().split(' ')]
if n > 3:
	print(1, 1)
	print(-a[0])
	print(2, n)
	lst = []
	for i in range(1, n):
		lst.append(str(a[i] * (n - 1)))
	print(' '.join(lst))
	print(1, n)
	lst2 = ['0'] + [str(-n * int(a) // (n - 1)) for a in lst]
	print(' '.join(lst2))
elif n == 2:
	print(1, 1)
	print(-a[0])
	print(2, 2)
	print(-a[1])
	print(1, 2)
	print(0, 0)
elif n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
elif n == 3:
	print(1, 1)
	print(-a[0])
	print(2, 2)
	print(-a[1])
	print(3, 3)
	print(-a[2])


import sys
input = sys.stdin.readline
import math
n = int(input())
arr = list(map(int, input().split()))
if n <= 3:
	for i in range(n):
		print(i + 1, i + 1)
		print(-arr[i])
	for i in range(3 - n):
		print(1, 1)
		print(0)
else:
	ans = [[], [], []]
	for i in range(len(arr) - 1):
		temp = arr[i] % n * (n - 1)
		ans[0].append(temp)
		arr[i] += temp
	for i in range(len(arr) - 1):
		temp = -arr[i]
		ans[1].append(temp)
		arr[i] += temp
	ans[1].append(0)
	print(1, n - 1)
	for num in ans[0]:
		print(num, end=' ')
	print()
	print(1, n)
	for num in ans[1]:
		print(num, end=' ')
	print()
	print(n, n)
	print(-arr[len(arr) - 1])


import sys
cases = False

def c2(n):
	return n * (n - 1) // 2

def get():
	return list(map(int, input().split()))

def bits(n: int):
	return list(bin(n)).count('1')

def main(test_case=False):
	n = int(input()) if test_case else 1
	for _ in range(n):
		test()

def flush():
	sys.stdout.flush()

def parr(arr):
	print(*arr, sep=' ')

def gcd(a, b):
	while b:
		if b % a == 0:
			break
		tmp = a
		a = b % a
		b = tmp
	return a

def ext_gcd(a: int, b: int):
	if b == 0:
		return [a, [1, 0]]
	res = ext_gcd(b, a % b)
	g = res[0]
	x1 = res[1][0]
	y1 = res[1][1]
	x = y1
	y = x1 - y1 * (a // b)
	return [g, [x, y]]

def test():
	n = int(input())
	a = get()
	if n == 1:
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		print(1, 1)
		print(-a[0])
		return
	print(1, 1)
	print(-a[0])
	a[0] = 0
	k = ext_gcd(n, n - 1)
	print(2, n)
	for i in range(n - 1):
		temp = -k[1][1] * a[i + 1] * (n - 1)
		a[i + 1] += temp
		print(temp, end=' ')
	print('')
	print(1, n)
	for i in range(n):
		print(-a[i], ' ')
main(cases)


import sys

def i():
	return sys.stdin.readline()[:-1]
n = int(i())
nums = list(map(int, i().split()))
if n == 1:
	print('1 1')
	print('0')
	print('1 1')
	print('0')
	print('1 1')
	print(-nums[0])
else:
	print(1, n - 1)
	for x in range(len(nums) - 1):
		print((n - 1) * (nums[x] % n), end=' ')
	print()
	print(n, n)
	print(-nums[n - 1])
	print(1, n)
	for x in range(len(nums) - 1):
		print(-(nums[x] + (n - 1) * (nums[x] % n)), end=' ')
	print('0')


total = int(input())
num_l = list(map(int, input().split()))
if total == 1:
	print('1 1')
	print(-num_l[0])
	print('1 1')
	print('0')
	print('1 1')
	print('0')
elif total == 2:
	print('1 1')
	print(-num_l[0])
	print('2 2')
	print(-num_l[1])
	print('1 1')
	print('0')
else:
	print('1 ' + str(total - 1))
	mul1 = total - 1
	mul1_l = []
	for count in range(total - 1):
		mul1_l.append(mul1 * num_l[count])
	print(*mul1_l)
	print('1 ' + str(total))
	mul2 = total
	mul2_l = []
	for count in range(total - 1):
		mul2_l.append(-mul2 * num_l[count])
	mul2_l += [0]
	print(*mul2_l)
	print(str(total) + ' ' + str(total))
	print(-num_l[total - 1])


import sys
(_ord, inp, num, neg, _Index) = (lambda x: x, [], 0, False, 0)
(i, s) = (0, sys.stdin.buffer.read())
try:
	while True:
		if s[i] >= b'0'[0]:
			num = 10 * num + _ord(s[i]) - 48
		elif s[i] == b'-'[0]:
			neg = True
		elif s[i] != b'\r'[0]:
			inp.append(-num if neg else num)
			(num, neg) = (0, False)
		i += 1
except IndexError:
	pass
if s and s[-1] >= b'0'[0]:
	inp.append(-num if neg else num)

def fin(size=None):
	global _Index
	if size == None:
		ni = _Index
		_Index += 1
		return inp[ni]
	else:
		ni = _Index
		_Index += size
		return inp[ni:ni + size]
_T_ = 1
for _t_ in range(_T_):
	n = fin()
	a = fin(n)
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		break
	print(n, n)
	print(-a[-1])
	a[-1] -= a[-1]
	print(1, n - 1)
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
		a[i] += a[i] * (n - 1)
	print()
	print(1, n)
	for i in range(n):
		print(-a[i], end=' ')
		a[i] -= a[i]
	print()


n = int(input())
l = [int(x) for x in input().split()]
print(1, 1)
print(l[0] * -1)
l[0] = 0
if n - 1 == 0:
	print(1, 1)
	print(0)
else:
	print(2, n)
	for i in range(1, n):
		x = l[i] % n
		print((n - 1) * x, end=' ')
		l[i] += (n - 1) * x
	print()
print(1, n)
for i in l:
	print(i * -1, end=' ')
print()


import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = lambda : sys.stdin.buffer.readline().rstrip()
q = int(input())
w = list(map(int, input().split()))
if q == 1:
	print(1, 1)
	print(-w[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, 1)
	print(-w[0])
	print(2, q)
	print(*[(q - 1) * w[i] for i in range(1, q)])
	print(1, q)
	print(*[0] + [-q * w[i] for i in range(1, q)])


import sys
n = int(sys.stdin.readline())
data = [int(d) for d in sys.stdin.readline().strip().split()]
if n > 1:
	print('1 ' + str(n))
	first_iter = []
	for i in range(len(data)):
		first_iter.append(len(data) * (len(data) - 1 - data[i]))
	print(' '.join([str(i) for i in first_iter]))
	for i in range(len(data)):
		data[i] += first_iter[i]
	second_iter = [d * -1 for d in data[1:]]
	print('2 ' + str(n))
	print(' '.join([str(i) for i in second_iter]))
	print('1 1')
	print(str(data[0] * -1))
else:
	print('1 1')
	print(str(data[0] * -1))
	print('1 1')
	print('0')
	print('1 1')
	print('0')


PI = 3.141592653589793
INF = 999999999
MOD = 1000000007

def add(x, y):
	return (x + y) % MOD

def sub(x, y):
	return (x - y + MOD) % MOD

def mul(x, y):
	return x * y % MOD

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)

def lcm(x, y):
	return x * y // gcd(x, y)

def power(x, y):
	res = 1
	x %= MOD
	while y != 0:
		if y & 1:
			res = mul(res, x)
		y >>= 1
		x = mul(x, x)
	return res

def mod_inv(n):
	return power(n, MOD - 2)

def prob(p, q):
	return mul(p, power(q, MOD - 2))

def ii():
	return int(input())

def li():
	return [int(i) for i in input().split()]

def ls():
	return [i for i in input().split()]
for t in range(1):
	n = ii()
	a = li()
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(1)
		print(1, 1)
		print(-1)
		continue
	print(1, n)
	ans = []
	for i in range(1, n):
		ans.append(a[i] % (n - 1))
	store = [n]
	for i in range(n - 1):
		store.append(n * (n - 1 - ans[i]))
	print(*store)
	print(2, n)
	for i in range(0, n):
		a[i] += store[i]
		a[i] *= -1
	print(*a[1:])
	print(1, 1)
	print(a[0])


def solve():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return
	print(1, n - 1)
	for i in range(n - 1):
		if a[i] % n == 0:
			print(0, end=' ')
			continue
		k = a[i]
		a[i] += k * (n - 1)
		print(k * (n - 1), end=' ')
	print()
	print(2, n)
	for i in range(1, n):
		if a[i] % n == 0:
			print(0, end=' ')
			continue
		k = a[i]
		a[i] += k * (n - 1)
		print(k * (n - 1), end=' ')
	print()
	print(1, n)
	for i in range(n):
		print(-a[i], end=' ')
	print()
solve()


from sys import stdin
input = stdin.readline

def A():
	t = int(input())
	for _ in range(t):
		d = [0] * 26
		n = int(input())
		for j in range(n):
			for i in input().rstrip():
				d[ord(i) - ord('a')] += 1
		truth = True
		for i in range(26):
			if d[i] % n != 0:
				truth = False
				break
		if truth:
			print('YES')
		else:
			print('NO')

def B():
	n = int(input())
	a = sorted(list(map(int, input().split())))
	baseCost = sum(a) - n
	c = 2
	cost = 0
	while True:
		cost = 0
		for i in range(n):
			cost += abs(a[i] - c ** i)
		if cost < baseCost:
			c += 1
			baseCost = cost
		else:
			break
	print(baseCost)

def C():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(-1 * a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return
	k = [(n - 1 - a[i] % (n - 1)) * n for i in range(n)]
	print(1, n)
	print(*k)
	print(1, 1)
	print(-1 * (k[0] + a[0]))
	print(2, n)
	print(*[-1 * (k[i] + a[i]) for i in range(1, n)])
C()


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print('1 1')
	print('0')
	print('1 1')
	print('0')
	print('1 1')
	print(-a[0])
else:
	print('1', n - 1)
	for i in range(n - 1):
		print((n - 1) * a[i], end=' ')
	print('')
	print('1', n)
	for i in range(n):
		print(-n * a[i], end=' ')
	print('')
	print(n, n)
	print((n - 1) * a[n - 1])


n = int(input())
a = list(map(int, input().split()))

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a, m):
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
if n == 1:
	i = 0
	print(1, 1)
	print(-1 * a[i])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	exit(0)
print(1, n - 1)
for i in range(n - 1):
	tba = -a[i] % n * modinv(n - 1, n) % n * (n - 1)
	a[i] += tba
	print(tba, end=' ')
print()
print(2, n)
for i in range(1, n):
	tba = -a[i] % n * modinv(n - 1, n) * (n - 1)
	a[i] += tba
	print(tba, end=' ')
print()
print(1, n)
for i in range(n):
	tba = a[i] * -1
	print(tba, end=' ')
print()


def sol():
	n = int(input())
	arr = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(-1 * arr[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		return 0
	print(n, n)
	print(-1 * arr[n - 1])
	arr[-1] = 0
	print(1, n - 1)
	for i in range(n - 1):
		print((n - 1) * arr[i], end=' ')
		arr[i] += (n - 1) * arr[i]
	print('\n' + '1', n)
	for i in range(n):
		print(-1 * arr[i], end=' ')
sol()


from sys import stdin, stdout
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	n = nmbr()
	a = lst()
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		continue
	print(1, n)
	for i in range(n):
		stdout.write(str(-n * a[i]) + ' ')
	print()
	print(1, n - 1)
	for i in range(n - 1):
		stdout.write(str((n - 1) * a[i]) + ' ')
	print()
	print(n, n)
	print(a[-1] * (n - 1))


n = int(input())
a = [int(x) for x in input().split()]
if n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	exit(0)
print(1, 1)
print(-a[0])
a[0] = 0
print(2, n)
for i in range(1, n):
	print(a[i] * (n - 1), end=' ')
print()
print(1, n)
for i in range(n):
	print(-a[i] * n, end=' ')
print()


n = int(input())
s = list(map(int, input().split()))
if n > 1:
	print(n, n)
	print(n - s[-1] % n)
	s[-1] += n - s[-1] % n
	print(1, n - 1)
	for i in range(n - 1):
		f = s[i] * (n - 1)
		print(f, end=' ')
		s[i] += f
	print()
	print(1, n)
	print(*[-i for i in s])
else:
	print(1, 1)
	print(-s[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)


n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-l[0])
else:
	print(1, 1)
	print(-l[0])
	l[0] = 0
	print(2, n)
	valarr = []
	for i in range(1, n):
		temp = n - 1
		val = l[i] % n * temp
		l[i] += val
		valarr.append(val)
	print(*valarr)
	print(1, n)
	arr = []
	for i in range(n):
		arr.append(-l[i])
	print(*arr)


from os import path
import sys
from heapq import heappush, heappop
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input().rstrip()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def bo(i):
	return ord(i) - ord('a')
file = 1

def solve():
	n = ii()
	a = li()
	if n == 1:
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		print(1, 1)
		print(-a[0])
		return
	print(1, 1)
	print(a[0] * n - a[0])
	print(2, n)
	for i in range(1, n):
		print(a[i] * (n - 1), end=' ')
	print()
	print(1, n)
	for i in range(n):
		print(-a[i] * n, end=' ')
if file:
	if path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	else:
		input = sys.stdin.readline
solve()


n = int(input())
liste = list(map(int, input().split(' ')))
answer = []
if n == 1:
	a = liste[0]
	answer = ['1 1', str(-a), '1 1', str(a), '1 1', str(-a)]
else:
	answer.append('1 ' + str(n))
	answer.append(' '.join([str(-n * liste[i]) for i in range(n)]))
	answer.append('1 1')
	answer.append(str((n - 1) * liste[0]))
	answer.append('2 ' + str(n))
	answer.append(' '.join([str((n - 1) * liste[i]) for i in range(1, n)]))
print('\n'.join(answer))


n = int(input())
a = list(map(int, input().split()))
if n > 1:
	print(1, n)
	for i in a:
		print(-1 * i * n, end=' ')
	print('')
	print(1, n - 1)
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
	print('')
	print(n, n)
	print(-a[n - 1] + n * a[n - 1])
else:
	print(n, n)
	print(-a[n - 1])
	print(n, n)
	print(0)
	print(n, n)
	print(0)


n = int(input())
a = list(map(int, input().split()))
b = []
if n > 1:
	print(1, n - 1)
else:
	print(1, 1)
	print(0)
for i in range(n - 1):
	ab = a[i] % n
	a[i] += ab * (n - 1)
	b.append(ab * (n - 1))
if b:
	print(*b)
print(n, n)
ab = a[n - 1] % n
a[n - 1] -= ab
print(-ab)
b = []
print(1, n)
for i in range(n):
	b.append(-a[i])
print(*b)


import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
rep = range
R = range

def Golf():
	(n, *t) = map(int, open(0).read().split())

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

def LS():
	return [i for i in input().split()]

def MI():
	return map(int, input().split())

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def NLI(n):
	return [[int(i) for i in input().split()] for i in range(n)]

def NLI_(n):
	return [[int(i) - 1 for i in input().split()] for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def RA():
	return map(int, open(0).read().split())

def RLI(n=8, a=1, b=10):
	return [random.randint(a, b) for i in range(n)]

def RI(a=1, b=10):
	return random.randint(a, b)

def Rtest(T):
	(case, err) = (0, 0)
	for i in range(T):
		inp = INP()
		(a1, ls) = naive(*inp)
		a2 = solve(*inp)
		if a1 != a2:
			print((a1, a2), inp)
			err += 1
		case += 1
	print('Tested', case, 'case with', err, 'errors')

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in R(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def accum(ls):
	rt = [0]
	for i in ls:
		rt += [rt[-1] + i]
	return rt

def bit_combination(n, base=2):
	rt = []
	for tb in R(base ** n):
		s = [tb // base ** bt % base for bt in R(n)]
		rt += [s]
	return rt

def gcd(x, y):
	if y == 0:
		return x
	if x % y == 0:
		return y
	while x % y != 0:
		(x, y) = (y, x % y)
	return y

def YN(x):
	print(['NO', 'YES'][x])

def Yn(x):
	print(['No', 'Yes'][x])

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('WENS', FourNb))
cursol = dict(zip('LRUD', FourNb))
l_alp = string.ascii_lowercase
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
input = lambda : sys.stdin.readline().rstrip()
show_flg = False
show_flg = True
ans = 0
T = 1
n = I()
a = LI()
if n == 1:
	for i in range(3):
		print(1, 1)
		print(a[0] * (-1) ** (1 + i))
	exit()
c = [n - 1 - i % (n - 1) for i in a]
(x1, x2) = ([], [])
for i in range(n):
	p = c[i]
	x1 += (p * n,)
	a[i] += p * n
for i in range(1, n):
	q = a[i] // (n - 1)
	x2 += (-q * (n - 1),)
	a[i] += -q * (n - 1)
print(1, n)
print(*x1)
print(2, n)
print(*x2)
print(1, 1)
print(-a[0])


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
if n == 1:
	for _ in range(3):
		print(1, 1)
		print(-a[0])
		a[0] = 0
	exit(0)
print(1, 1)
print(-a[0])
a[0] = 0
print(2, n)
res = [0] * n
for i in range(1, n):
	res[i] += a[i] % n * (n - 1)
	a[i] += a[i] % n * (n - 1)
print(*res[1:])
print(1, n)
res = [0] * n
for i in range(n):
	res[i] = -a[i]
print(*res)


n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-l[0])
else:
	print(1, n)
	arr = []
	for i in range(n):
		arr.append(-l[i] * n)
	print(*arr)
	arr2 = []
	print(1, n - 1)
	for i in range(n - 1):
		arr2.append(l[i] * (n - 1))
	print(*arr2)
	print(n, n)
	print(l[-1] * (n - 1))


import sys
input = sys.stdin.readline
n = int(input())
arr = list(map(int, input().split()))
g = []
for i in range(n - 1):
	t = arr[i] % n
	g.append(t * (n - 1))
	arr[i] += t * (n - 1)
if n == 1:
	print(1, 1)
	print(-arr[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
elif n == 2:
	print(1, 1)
	print(-arr[0])
	print(2, 2)
	print(-arr[1])
	print(1, 1)
	print(0)
else:
	print(1, n - 1)
	print(*g)
	print(n, n)
	print(-(arr[-1] % n))
	arr[-1] += -(arr[-1] % n)
	g = []
	for num in arr:
		g.append(-num)
	print(1, n)
	print(*g)


import sys
input = sys.stdin.readline

def print(val):
	sys.stdout.write(val + '\n')

def prog():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print('1 1')
		print(f'{-a[0]}')
		print('1 1')
		print('0')
		print('1 1')
		print('0')
		return
	print('1 1')
	print(f'{-a[0]}')
	a[0] = 0
	output = [0] * (n - 1)
	for i in range(1, n):
		added = a[i] % n * (n - 1)
		output[i - 1] = str(added)
		a[i] += added
		a[i] = -a[i]
	print(f'2 {n}')
	print(' '.join(output))
	print(f'1 {n}')
	print(' '.join(map(str, a)))
prog()


import math
import collections
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect_left as bsl
from bisect import bisect_right as bsr
import heapq as hq
setrecursionlimit(2 ** 20)
t = 1
for _ in range(t):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().rstrip().split()))
	if n > 1:
		print(1, n - 1)
		for i in range(n - 1):
			print((n - 1) * a[i], end=' ')
		print()
		print(n, n)
		print(-a[-1])
		print(1, n)
		for i in range(n - 1):
			print(-n * a[i], end=' ')
		print(0)
	else:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)


N = int(input())
array = [int(x) for x in input().split()]
if N == 1:
	print(1, 1)
	print(-array[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, N - 1)
	tobeprinted = []
	for i in range(N - 1):
		tobeprinted.append(array[i] * (N - 1))
	print(*tobeprinted)
	print(N, N)
	print(-array[-1])
	print(1, N)
	array = [-N * x for x in array[0:N - 1]] + [0]
	print(*array)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))
n = N()
a = RLL()
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-a[0])
else:
	print(1, n)
	t1 = []
	for i in range(n):
		t1.append(n * (n - a[i] - 1))
	print_list(t1)
	print(1, n - 1)
	print_list([-(a[i] + t1[i]) for i in range(n - 1)])
	print(n, n)
	print(-(a[-1] + t1[-1]))


import math
from sys import stdin
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1000000000.0) + 7
inf = float('inf')
(n,) = gil()
a = gil()
if n == 1:
	v = a[0] + 2
	print(1, 1)
	print(1)
	print(1, 1)
	print(1)
	print(1, 1)
	print(-v)
else:
	print(n, n)
	print(-a[-1])
	a[-1] = 0
	print(1, n - 1)
	for i in range(n - 1):
		md = a[i] % n
		if md:
			cmd = n - md
			val = (n - cmd) * (n - 1)
			a[i] += val
			print(val, end=' ')
		else:
			print(0, end=' ')
	print()
	print(1, n)
	for val in a:
		print(-val, end=' ')
	print()


from sys import stdin, stdout
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
ans = []
if n == 1:
	print(1, 1)
	print(1)
	print(1, 1)
	print(1)
	print(1, 1)
	print(-a[0] - 2)
else:
	ans.append([1, n - 1])
	temp = []
	for i in range(n - 1):
		temp.append(a[i] * (n - 1))
		a[i] += a[i] * (n - 1)
	ans.append(temp)
	ans.append([2, n])
	temp = [0] * (n - 2) + [a[-1] * (n - 1)]
	a[-1] += temp[-1]
	ans.append(temp)
	ans.append([1, n])
	temp = []
	for i in range(n):
		temp.append(-a[i])
	ans.append(temp)
	for a in ans:
		print(*a, sep=' ')


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True
n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-l[0])
elif n == 2:
	print(1, 1)
	print(-l[0])
	print(2, 2)
	print(-l[1])
	print(1, 2)
	print(0, 0)
elif n == 3:
	print(1, 1)
	print(-l[0])
	print(2, 2)
	print(-l[1])
	print(3, 3)
	print(-l[2])
else:
	print(1, n)
	for i in range(0, n):
		print(-n * l[i], end=' ')
	l[-1] = l[-1] - n * l[-1]
	print('')
	print(1, n - 1)
	for i in range(0, n - 1):
		print((n - 1) * l[i], end=' ')
	print('')
	print(n, n)
	print(-l[-1])


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter

def data():
	return sys.stdin.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
from decimal import Decimal
mod = int(1000000000.0) + 7
INF = 10 ** 9
n = int(data())
a = mdata()
if n == 1:
	print(1, 1)
	out(-a[0])
	print(1, 1)
	out(0)
	print(1, 1)
	out(0)
	exit()
print(1, n - 1)
ans = []
for i in range(n - 1):
	ans.append((n - 1) * a[i])
	a[i] += (n - 1) * a[i]
outl(ans)
print(n, n)
out(-a[-1])
print(1, n)
a[-1] = 0
ans = []
for i in range(n):
	ans.append(-a[i])
outl(ans)


n = int(input())
a = list(map(int, input().split()))
c = []
k = []
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-a[0])
else:
	print(1, 1)
	print(-a[0])
	print(1, n)
	for i in range(1, n):
		c.append(-n * a[i])
		k.append((n - 1) * a[i])
	print(0, *c)
	print(2, n)
	print(*k)


import sys
(_ord, inp, num, neg, _Index) = (lambda x: x, [], 0, False, 0)
(i, s) = (0, sys.stdin.buffer.read())
try:
	while True:
		if s[i] >= b'0'[0]:
			num = 10 * num + _ord(s[i]) - 48
		elif s[i] == b'-'[0]:
			neg = True
		elif s[i] != b'\r'[0]:
			inp.append(-num if neg else num)
			(num, neg) = (0, False)
		i += 1
except IndexError:
	pass
if s and s[-1] >= b'0'[0]:
	inp.append(-num if neg else num)

def fin(size=None):
	global _Index
	if size == None:
		ni = _Index
		_Index += 1
		return inp[ni]
	else:
		ni = _Index
		_Index += size
		return inp[ni:ni + size]
n = fin()
vals = fin(n)
if n >= 2:
	print(1, n)
	ans = [-i * n for i in vals]
	print(*ans)
	print(2, n)
	a1 = [i * (n - 1) for i in vals[1:n]]
	print(*a1)
	print(1, 1)
	print(vals[0] * (n - 1))
else:
	print(1, 1)
	print(-vals[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print('1 1')
	print(-1 * arr[0])
	print('1 1')
	print(0)
	print('1 1')
	print(0)
else:
	print('1 1')
	print(-1 * arr[0])
	ans = []
	print('2 ' + str(n))
	for i in range(1, n):
		print((n - 1) * arr[i], end=' ')
		ans.append(n * arr[i])
	print()
	print('1 ' + str(n))
	print(0, end=' ')
	for d in ans:
		print(-1 * d, end=' ')
	print()


n = int(input())
a = [int(i) for i in input().split()]
if n == 1:
	print(1, 1)
	print(-a[-1])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n)
	for i in range(n):
		k = (n - 1 - a[i]) * n
		a[i] += k
		print(k, sep=' ', end=' ')
	print()
	print(1, n - 1)
	for i in range(n - 1):
		print(-a[i], sep=' ', end=' ')
	print()
	print(n, n)
	print(-a[n - 1])


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(a[0] * -1)
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n)
	ans = []
	for i in range(n):
		ans.append(a[i] * -1 * n)
	print(*ans)
	print(1, n - 1)
	res = []
	for i in range(n - 1):
		res.append(a[i] * (n - 1))
	print(*res)
	print(n, n)
	print(a[-1] * (n - 1))


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
	print(1, 1)
	print(-1 * a[-1])
else:
	print(1, n - 1)
	first = []
	for i in range(n - 1):
		first.append(a[i] * (n - 1))
	print(*first)
	print(n, n)
	print(n - a[-1])
	print(1, n)
	second = []
	for i in range(n - 1):
		second.append(-1 * a[i] * n)
	second.append(-1 * n)
	print(*second)


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print('1 1')
	print(-arr[0])
	print('1 1')
	print('0')
	print('1 1')
	print('0')
else:
	print('1 ' + str(n - 1))
	for i in range(len(arr) - 1):
		print(arr[i] % n * (n - 1), end=' ')
		arr[i] += arr[i] % n * (n - 1)
	print()
	print(str(n) + ' ' + str(n))
	print(n - arr[-1] % n)
	arr[-1] += n - arr[-1] % n
	print('1 ' + str(n))
	for i in range(len(arr)):
		print(-arr[i], end=' ')
	print()


mod = 10 ** 9 + 7

def solve():
	n = int(input())
	a = list(map(int, input().split()))
	if n == 1:
		print(1, 1)
		print(0)
	else:
		print(1, n - 1)
		for i in range(0, n - 1):
			print(a[i] * (n - 1), end=' ')
			a[i] = a[i] * n
		print()
	print(n, n)
	print(-a[n - 1])
	a[n - 1] = 0
	print(1, n)
	for i in range(n):
		a[i] = -a[i]
	print(*a)
t = 1
while t > 0:
	solve()
	t -= 1


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-1 * arr[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	lis = []
	for i in range(n):
		if arr[i] % n == 0:
			lis.append(arr[i] * -1)
			arr[i] = 0
		else:
			lis.append(arr[i] * n * -1)
			arr[i] += arr[i] * n * -1
	print(1, n)
	print(' '.join((str(x) for x in lis)))
	lis = []
	for i in range(n - 1):
		if arr[i] % (n - 1) == 0:
			lis.append(arr[i] * -1)
			arr[i] = 0
	print(1, n - 1)
	print(' '.join((str(x) for x in lis)))
	lis = []
	for i in range(1, n):
		if arr[i] % (n - 1) == 0:
			lis.append(arr[i] * -1)
			arr[i] = 0
	print(2, n)
	print(' '.join((str(x) for x in lis)))


import sys
_INPUT_LINES = sys.stdin.read().splitlines()
inp = iter(_INPUT_LINES).__next__
inar = lambda : list(map(int, inp().split()))
inin = lambda : int(inp())
inst = lambda : inp().decode().strip()
_T_ = 1
for _t_ in range(_T_):
	n = inin()
	a = inar()
	if n == 1:
		print(1, 1)
		print(-a[0])
		print(1, 1)
		print(0)
		print(1, 1)
		print(0)
		break
	print(n, n)
	print(-a[-1])
	a[-1] -= a[-1]
	print(1, n - 1)
	for i in range(n - 1):
		print(a[i] * (n - 1), end=' ')
		a[i] += a[i] * (n - 1)
	print()
	print(1, n)
	for i in range(n):
		print(-a[i], end=' ')
		a[i] -= a[i]
	print()


n = int(input())
a = list(map(int, input().split()))
b = []
if n == 1:
	print('1 1')
	print(n - a[0] % n)
	a[0] = a[0] + n - a[0] % n
	print('1 1')
	print(n - a[0] % n)
	a[0] = a[0] + n - a[0] % n
	print('1 1')
	print(-a[0])
else:
	for k in range(n - 1):
		b.append(a[k] % n * (n - 1))
		a[k] = a[k] + a[k] % n * (n - 1)
	print('1', n - 1)
	print(' '.join(map(str, b)))
	print(n, n)
	print(n - a[n - 1] % n)
	a[n - 1] = a[n - 1] + n - a[n - 1] % n
	print('1', n)
	for k in range(n):
		a[k] = -1 * a[k]
	print(' '.join(map(str, a)))


n = int(input())
a = list(map(int, input().split()))
print(1, 1)
print(-a[0])
a[0] = 0
if n == 1:
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n)
	for x in a:
		print(-(x % (n - 1) * n), end=' ')
	print()
	print(2, n)
	for x in a[1:]:
		print(-(x - x % (n - 1) * n), end=' ')


n = int(input())
a = list(map(int, input().split()))
if n == 1:
	print(1, 1)
	print(-a[0])
	print(1, 1)
	print(0)
	print(1, 1)
	print(0)
else:
	print(1, n - 1)
	for i in range(n - 1):
		oper = (n - 1) * (a[i] % n)
		a[i] += oper
		print(oper, end=' ')
	print()
	print(n, n)
	print(-a[-1])
	a[-1] = 0
	print(1, n)
	print(' '.join(list(map(lambda x: str(-x), a))))