#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using std::cin;
using std::cout;
using std::lower_bound;
using std::string;
using std::upper_bound;
using std::vector;
using vi = vector<long long>;
using vii = vector<vi>;
using pii = std::pair<long long, long long>;
constexpr long long MOD = 1e9 + 7;
constexpr long long MAX = 3e6;
constexpr long long inf = (1ll << 60);
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <typename T>
struct Segment_tree {
  long long N;
  T mem;
  vector<T> node;
  Segment_tree(vector<T> &X, T m) : mem(m) {
    long long sz = X.size();
    N = 1;
    while (N < sz) N *= 2;
    node.resize(2 * N - 1, mem);
    for (long long i = (long long)(0); i < (long long)(sz); i++)
      node[N - 1 + i] = X[i];
    for (long long i = (long long)(N - 2); (long long)(0) <= i; i--) {
      node[i] = Compare(node[i * 2 + 1], node[i * 2 + 2]);
    }
  }
  T Compare(T &A, T &B) { return std::max(A, B); }
  void update(long long X, T val) {
    X += N - 1;
    node[X] = val;
    while (X > 0) {
      X = (X - 1) / 2;
      node[X] = Compare(node[X * 2 + 1], node[X * 2 + 2]);
    }
  }
  T Query(long long a, long long b, long long now, long long l, long long r) {
    if (r < 0) r = N;
    if (r <= a || b <= l) return mem;
    if (a <= l && r <= b) return node[now];
    auto vl = Query(a, b, now * 2 + 1, l, (l + r) / 2),
         vr = Query(a, b, now * 2 + 2, (l + r) / 2, r);
    return Compare(vl, vr);
  }
};
template <typename T>
struct lazy_Segment_tree {
  int N;
  vector<T> node, lazy;
  T INF;
  lazy_Segment_tree(vector<T> X, T Y) : INF(Y) {
    N = 1;
    while (X.size() > N) N *= 2;
    node.resize(2 * N - 1, Y);
    lazy.resize(2 * N - 1);
    for (long long i = (long long)(0); i < (long long)(X.size()); i++)
      node[i + N - 1] = X[i];
    for (long long i = (long long)(N - 2); (long long)(0) <= i; i--)
      node[i] = compare(node[i * 2 + 1], node[i * 2 + 2]);
  }
  T compare(T X, T Y) { return std::max(X, Y); }
  T plus(T X, int l, int r) { return X; }
  void eval(int now, int l, int r) {
    if (lazy[now] == 0) return;
    node[now] += lazy[now];
    if (r - l > 1) {
      lazy[now * 2 + 1] += plus(lazy[now], l, r);
      lazy[now * 2 + 2] += plus(lazy[now], l, r);
    }
    lazy[now] = 0;
  }
  void update(int a, int b, T add, int now = 0, int l = 0, int r = -1) {
    if (r < 0) r = N;
    eval(now, l, r);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazy[now] += add;
      eval(now, l, r);
    } else {
      update(a, b, add, now * 2 + 1, l, (r + l) / 2);
      update(a, b, add, now * 2 + 2, (r + l) / 2, r);
      node[now] = compare(node[now * 2 + 1], node[now * 2 + 2]);
    }
  }
  T Query(int a, int b, int now = 0, int l = 0, int r = -1) {
    if (r < 0) r = N;
    eval(now, l, r);
    if (b <= l || r <= a) return INF;
    if (a <= l && r <= b) return node[now];
    return compare(Query(a, b, now * 2 + 1, l, (r + l) / 2),
                   Query(a, b, now * 2 + 2, (r + l) / 2, r));
  }
};
struct Tree {
  int N;
  vii dp;
  vi dist;
  Tree(vii edge) {
    N = edge.size();
    dp.resize(N);
    dist.resize(N, -1);
    for (int i = 0; i < N; i++) dp[i].resize(30);
    dist[0] = dp[0][0] = 0;
    std::queue<int> que;
    que.push(0);
    while (!que.empty()) {
      int now = que.front();
      que.pop();
      for (int i = 0; i < edge[now].size(); i++) {
        int next = edge[now][i];
        if (dist[next] == -1) {
          dist[next] = dist[now] + 1;
          que.push(next);
          dp[next][0] = now;
        }
      }
    }
    for (int i = 1; i < 30; i++) {
      for (int j = 0; j < N; j++) dp[j][i] = dp[dp[j][i - 1]][i - 1];
    }
  }
  int LCA(int X, int Y) {
    if (dist[X] < dist[Y]) std::swap(X, Y);
    {
      int Z = dist[X] - dist[Y];
      for (int i = 0; i < 30; i++) {
        if (Z & (1 << i)) {
          X = dp[X][i];
        }
      }
    }
    if (X == Y) return X;
    for (int i = 29; i >= 0; i--) {
      if (dp[X][i] != dp[Y][i]) {
        X = dp[X][i];
        Y = dp[Y][i];
      }
    }
    return dp[X][0];
  }
};
struct Binary_indexed_tree {
  int N;
  vi bit;
  Binary_indexed_tree(int n) : N(n) { bit.resize(N + 1, 0); }
  void add(int x, long long a) {
    for (x; x <= N; x += (x & -x)) bit[x] += a;
  }
  long long sum(int x) {
    long long ret = 0;
    for (x; x > 0; x -= (x & -x)) ret += bit[x];
    return ret;
  }
  long long lower_bound(long long X) {
    if (sum(N) < X) return -1;
    long long ret = 0, memo = 1, sum = 0;
    while (memo * 2 <= N) memo *= 2;
    while (memo > 0) {
      if (memo + ret <= N && sum + bit[memo + ret] < X) {
        sum += bit[memo + ret];
        ret += memo;
      }
      memo /= 2;
    }
    return ret + 1;
  }
};
struct Union_Find {
  long long N;
  vi par;
  vi siz;
  Union_Find(int n) : N(n) {
    par.resize(N);
    siz.resize(N, 1);
    for (long long i = (long long)(0); i < (long long)(N); i++) par[i] = i;
  }
  long long root(long long X) {
    if (par[X] == X) return X;
    return par[X] = root(par[X]);
  }
  bool same(long long X, long long Y) { return root(X) == root(Y); }
  void unite(long long X, long long Y) {
    X = root(X);
    Y = root(Y);
    if (X == Y) return;
    par[X] = Y;
    siz[Y] += siz[X];
    siz[X] = 0;
  }
  long long size(long long X) { return siz[root(X)]; }
};
long long modpow(long long a, long long n, long long mod) {
  long long res = 1;
  while (n > 0) {
    if (n & 1) res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}
vi fac, finv, inv;
void COMinit() {
  fac.resize(MAX);
  finv.resize(MAX);
  inv.resize(MAX);
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}
long long COM(long long n, long long r) {
  if (n < r || n < 0 || r < 0) return 0;
  return fac[n] * finv[r] % MOD * finv[n - r] % MOD;
}
void comp(vi &A) {
  std::map<long long, long long> memo;
  for (long long i = (long long)(0); i < (long long)(A.size()); i++)
    memo[A[i]] = 0;
  long long cnt = 1;
  for (auto &p : memo) p.second = cnt++;
  for (long long i = (long long)(0); i < (long long)(A.size()); i++)
    A[i] = memo[A[i]];
}
void dec(std::map<long long, long long> &mem, long long X) {
  mem[X]--;
  if (mem[X] == 0) mem.erase(X);
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  long long N;
  cin >> N;
  vi A(N);
  for (long long i = (long long)(0); i < (long long)(N); i++) cin >> A[i];
  cout << 1 << " " << 1 << "\n";
  cout << -A[0] << "\n";
  A[0] = 0;
  if (N == 1)
    cout << 1 << " " << 1 << "\n" << 0 << "\n";
  else {
    cout << 2 << " " << N << "\n";
    for (long long i = (long long)(1); i < (long long)(N); i++) {
      long long X = A[i] % N * (N - 1);
      cout << X << " ";
      A[i] += X;
    }
    cout << "\n";
  }
  cout << 1 << " " << N << "\n";
  for (long long i = (long long)(0); i < (long long)(N); i++)
    cout << -A[i] << " ";
  cout << "\n";
}

### Prompt

Create a solution in Cpp for the following 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

### Response

```cpp
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using std::cin;
using std::cout;
using std::lower_bound;
using std::string;
using std::upper_bound;
using std::vector;
using vi = vector<long long>;
using vii = vector<vi>;
using pii = std::pair<long long, long long>;
constexpr long long MOD = 1e9 + 7;
constexpr long long MAX = 3e6;
constexpr long long inf = (1ll << 60);
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <typename T>
struct Segment_tree {
  long long N;
  T mem;
  vector<T> node;
  Segment_tree(vector<T> &X, T m) : mem(m) {
    long long sz = X.size();
    N = 1;
    while (N < sz) N *= 2;
    node.resize(2 * N - 1, mem);
    for (long long i = (long long)(0); i < (long long)(sz); i++)
      node[N - 1 + i] = X[i];
    for (long long i = (long long)(N - 2); (long long)(0) <= i; i--) {
      node[i] = Compare(node[i * 2 + 1], node[i * 2 + 2]);
    }
  }
  T Compare(T &A, T &B) { return std::max(A, B); }
  void update(long long X, T val) {
    X += N - 1;
    node[X] = val;
    while (X > 0) {
      X = (X - 1) / 2;
      node[X] = Compare(node[X * 2 + 1], node[X * 2 + 2]);
    }
  }
  T Query(long long a, long long b, long long now, long long l, long long r) {
    if (r < 0) r = N;
    if (r <= a || b <= l) return mem;
    if (a <= l && r <= b) return node[now];
    auto vl = Query(a, b, now * 2 + 1, l, (l + r) / 2),
         vr = Query(a, b, now * 2 + 2, (l + r) / 2, r);
    return Compare(vl, vr);
  }
};
template <typename T>
struct lazy_Segment_tree {
  int N;
  vector<T> node, lazy;
  T INF;
  lazy_Segment_tree(vector<T> X, T Y) : INF(Y) {
    N = 1;
    while (X.size() > N) N *= 2;
    node.resize(2 * N - 1, Y);
    lazy.resize(2 * N - 1);
    for (long long i = (long long)(0); i < (long long)(X.size()); i++)
      node[i + N - 1] = X[i];
    for (long long i = (long long)(N - 2); (long long)(0) <= i; i--)
      node[i] = compare(node[i * 2 + 1], node[i * 2 + 2]);
  }
  T compare(T X, T Y) { return std::max(X, Y); }
  T plus(T X, int l, int r) { return X; }
  void eval(int now, int l, int r) {
    if (lazy[now] == 0) return;
    node[now] += lazy[now];
    if (r - l > 1) {
      lazy[now * 2 + 1] += plus(lazy[now], l, r);
      lazy[now * 2 + 2] += plus(lazy[now], l, r);
    }
    lazy[now] = 0;
  }
  void update(int a, int b, T add, int now = 0, int l = 0, int r = -1) {
    if (r < 0) r = N;
    eval(now, l, r);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazy[now] += add;
      eval(now, l, r);
    } else {
      update(a, b, add, now * 2 + 1, l, (r + l) / 2);
      update(a, b, add, now * 2 + 2, (r + l) / 2, r);
      node[now] = compare(node[now * 2 + 1], node[now * 2 + 2]);
    }
  }
  T Query(int a, int b, int now = 0, int l = 0, int r = -1) {
    if (r < 0) r = N;
    eval(now, l, r);
    if (b <= l || r <= a) return INF;
    if (a <= l && r <= b) return node[now];
    return compare(Query(a, b, now * 2 + 1, l, (r + l) / 2),
                   Query(a, b, now * 2 + 2, (r + l) / 2, r));
  }
};
struct Tree {
  int N;
  vii dp;
  vi dist;
  Tree(vii edge) {
    N = edge.size();
    dp.resize(N);
    dist.resize(N, -1);
    for (int i = 0; i < N; i++) dp[i].resize(30);
    dist[0] = dp[0][0] = 0;
    std::queue<int> que;
    que.push(0);
    while (!que.empty()) {
      int now = que.front();
      que.pop();
      for (int i = 0; i < edge[now].size(); i++) {
        int next = edge[now][i];
        if (dist[next] == -1) {
          dist[next] = dist[now] + 1;
          que.push(next);
          dp[next][0] = now;
        }
      }
    }
    for (int i = 1; i < 30; i++) {
      for (int j = 0; j < N; j++) dp[j][i] = dp[dp[j][i - 1]][i - 1];
    }
  }
  int LCA(int X, int Y) {
    if (dist[X] < dist[Y]) std::swap(X, Y);
    {
      int Z = dist[X] - dist[Y];
      for (int i = 0; i < 30; i++) {
        if (Z & (1 << i)) {
          X = dp[X][i];
        }
      }
    }
    if (X == Y) return X;
    for (int i = 29; i >= 0; i--) {
      if (dp[X][i] != dp[Y][i]) {
        X = dp[X][i];
        Y = dp[Y][i];
      }
    }
    return dp[X][0];
  }
};
struct Binary_indexed_tree {
  int N;
  vi bit;
  Binary_indexed_tree(int n) : N(n) { bit.resize(N + 1, 0); }
  void add(int x, long long a) {
    for (x; x <= N; x += (x & -x)) bit[x] += a;
  }
  long long sum(int x) {
    long long ret = 0;
    for (x; x > 0; x -= (x & -x)) ret += bit[x];
    return ret;
  }
  long long lower_bound(long long X) {
    if (sum(N) < X) return -1;
    long long ret = 0, memo = 1, sum = 0;
    while (memo * 2 <= N) memo *= 2;
    while (memo > 0) {
      if (memo + ret <= N && sum + bit[memo + ret] < X) {
        sum += bit[memo + ret];
        ret += memo;
      }
      memo /= 2;
    }
    return ret + 1;
  }
};
struct Union_Find {
  long long N;
  vi par;
  vi siz;
  Union_Find(int n) : N(n) {
    par.resize(N);
    siz.resize(N, 1);
    for (long long i = (long long)(0); i < (long long)(N); i++) par[i] = i;
  }
  long long root(long long X) {
    if (par[X] == X) return X;
    return par[X] = root(par[X]);
  }
  bool same(long long X, long long Y) { return root(X) == root(Y); }
  void unite(long long X, long long Y) {
    X = root(X);
    Y = root(Y);
    if (X == Y) return;
    par[X] = Y;
    siz[Y] += siz[X];
    siz[X] = 0;
  }
  long long size(long long X) { return siz[root(X)]; }
};
long long modpow(long long a, long long n, long long mod) {
  long long res = 1;
  while (n > 0) {
    if (n & 1) res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}
vi fac, finv, inv;
void COMinit() {
  fac.resize(MAX);
  finv.resize(MAX);
  inv.resize(MAX);
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}
long long COM(long long n, long long r) {
  if (n < r || n < 0 || r < 0) return 0;
  return fac[n] * finv[r] % MOD * finv[n - r] % MOD;
}
void comp(vi &A) {
  std::map<long long, long long> memo;
  for (long long i = (long long)(0); i < (long long)(A.size()); i++)
    memo[A[i]] = 0;
  long long cnt = 1;
  for (auto &p : memo) p.second = cnt++;
  for (long long i = (long long)(0); i < (long long)(A.size()); i++)
    A[i] = memo[A[i]];
}
void dec(std::map<long long, long long> &mem, long long X) {
  mem[X]--;
  if (mem[X] == 0) mem.erase(X);
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  long long N;
  cin >> N;
  vi A(N);
  for (long long i = (long long)(0); i < (long long)(N); i++) cin >> A[i];
  cout << 1 << " " << 1 << "\n";
  cout << -A[0] << "\n";
  A[0] = 0;
  if (N == 1)
    cout << 1 << " " << 1 << "\n" << 0 << "\n";
  else {
    cout << 2 << " " << N << "\n";
    for (long long i = (long long)(1); i < (long long)(N); i++) {
      long long X = A[i] % N * (N - 1);
      cout << X << " ";
      A[i] += X;
    }
    cout << "\n";
  }
  cout << 1 << " " << N << "\n";
  for (long long i = (long long)(0); i < (long long)(N); i++)
    cout << -A[i] << " ";
  cout << "\n";
}

```