#include <bits/stdc++.h>
using namespace std;
const int N = 400031;
int n, ar[N];
set<int> local_maxima;
set<int>::iterator it;
long long dif[N];
int tests;
long long CUR_ANS;
int get_local_maximum(int start) {
  it = local_maxima.lower_bound(start);
  if (it == local_maxima.end()) return -1;
  return (*it);
}
void update_maxima(int ps) {
  if (local_maxima.find(ps) != local_maxima.end()) local_maxima.erase(ps);
  if (ps <= 1 || ps >= n) return;
  if (dif[ps] >= 0 && dif[ps + 1] <= 0) local_maxima.insert(ps);
}
pair<long long, long long> t[N * 4];
pair<long long, long long> combine(pair<long long, long long> p1,
                                   pair<long long, long long> p2) {
  if (p1.first < p2.first) return p1;
  return p2;
}
void build(int v, int tl, int tr) {
  if (tl == tr) {
    if (dif[tl] < 0)
      t[v] = make_pair(abs(dif[tl]), tl);
    else
      t[v] = make_pair(1e18, tl);
    return;
  }
  int sdfjahlfasfh = tl + tr;
  sdfjahlfasfh /= 2;
  build(v * 2, tl, sdfjahlfasfh);
  build(v * 2 + 1, sdfjahlfasfh + 1, tr);
  t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
void update(int v, int tl, int tr, int ps) {
  if (tl == tr) {
    if (dif[tl] < 0)
      t[v] = make_pair(abs(dif[tl]), tl);
    else
      t[v] = make_pair(1e18, tl);
    return;
  }
  int sdfjahlfasfh = tl + tr;
  sdfjahlfasfh /= 2;
  if (ps <= sdfjahlfasfh)
    update(v * 2, tl, sdfjahlfasfh, ps);
  else
    update(v * 2 + 1, sdfjahlfasfh + 1, tr, ps);
  t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
pair<long long, long long> get(int v, int tl, int tr, int l, int r) {
  if (l > r) return make_pair(1e18, 1e18);
  if (tl == l && tr == r) return t[v];
  int sdfjahlfasfh = tl + tr;
  sdfjahlfasfh /= 2;
  return combine(
      get(v * 2, tl, sdfjahlfasfh, l, min(r, sdfjahlfasfh)),
      get(v * 2 + 1, sdfjahlfasfh + 1, tr, max(sdfjahlfasfh + 1, l), r));
}
int main() {
  ios_base::sync_with_stdio(0);
  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> ar[i];
  }
  for (int i = 2; i < n; i++) {
    if (ar[i] >= ar[i - 1] && ar[i] >= ar[i + 1]) {
      local_maxima.insert(i);
    }
  }
  for (int i = 1; i <= n; i++) {
    dif[i] = ar[i] - ar[i - 1];
  }
  for (int i = 2; i <= n; i++) {
    CUR_ANS += abs(ar[i] - ar[i - 1]);
  }
  build(1, 1, n);
  cin >> tests;
  for (; tests; --tests) {
    int tp;
    cin >> tp;
    if (tp == 1) {
      int l, r, x;
      cin >> l >> r >> x;
      int P = get_local_maximum(l);
      if (P >= l && P <= r) {
        cout << CUR_ANS + 2 * x << endl;
        continue;
      }
      {
        long long best_aprox = CUR_ANS - 2 * x;
        if (l == 1) {
          long long aprox_first = CUR_ANS;
          aprox_first -= abs(dif[2]);
          aprox_first += abs(dif[2] - x);
          best_aprox = max(best_aprox, aprox_first);
        }
        if (r == n) {
          long long aprox_last = CUR_ANS;
          aprox_last -= abs(dif[n]);
          aprox_last += abs(dif[n] + x);
          best_aprox = max(best_aprox, aprox_last);
        }
        long long q_r = min(0ll + n - 1, 0ll + r - 1);
        long long q_l = max(1, l + 1);
        for (int i = l + 1; i < r; i++) {
          long long score_here = CUR_ANS;
          score_here -= abs(dif[i]);
          score_here -= abs(dif[i + 1]);
          score_here += abs(dif[i] + x);
          score_here += abs(dif[i + 1] - x);
          best_aprox = max(best_aprox, score_here);
        }
        if (l != 1 && l != n) {
          long long score_here = CUR_ANS;
          score_here -= abs(dif[l]);
          score_here -= abs(dif[l + 1]);
          score_here += abs(dif[l] + x);
          score_here += abs(dif[l + 1] - x);
          best_aprox = max(best_aprox, score_here);
        }
        if (r != 1 && r != n) {
          long long score_here = CUR_ANS;
          score_here -= abs(dif[r]);
          score_here -= abs(dif[r + 1]);
          score_here += abs(dif[r] + x);
          score_here += abs(dif[r + 1] - x);
          best_aprox = max(best_aprox, score_here);
        }
        cout << best_aprox << endl;
      }
    } else {
      int l, r, val;
      cin >> l >> r >> val;
      if (l != 1) {
        CUR_ANS -= abs(dif[l]);
      }
      dif[l] += val;
      if (l != 1) {
        CUR_ANS += abs(dif[l]);
      }
      if (r != n) {
        CUR_ANS -= abs(dif[r + 1]);
      }
      dif[r + 1] -= val;
      if (r != n) {
        CUR_ANS += abs(dif[r + 1]);
      }
      update_maxima(l - 1);
      update_maxima(l);
      update_maxima(r);
      update_maxima(r + 1);
      update(1, 1, n, l);
      if (r + 1 <= n) update(1, 1, n, r + 1);
    }
  }
  return 0;
}
