#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[100005];
long long curSum = 0;
const long long INF = 1e18;
class initITrangeMaxMin {
 private:
  long long f[4 * 100005];
  long long s[4 * 100005];

 public:
  void init(long long val) {
    for (long long i = 0; i < 4 * 100005; i++) f[i] = s[i] = val;
  }
  void updateR(long long k, long long l, long long r, long long pos,
               long long val) {
    if (r < pos || pos < l) return;
    if (pos <= l && r <= pos) {
      f[k] = val;
      s[k] = val;
      return;
    }
    long long mid = (l + r) / 2;
    updateR(k * 2, l, mid, pos, val);
    updateR(k * 2 + 1, mid + 1, r, pos, val);
    f[k] = max(f[k * 2], f[k * 2 + 1]);
    s[k] = min(s[k * 2], s[k * 2 + 1]);
  }
  void updateI(long long k, long long l, long long r, long long pos,
               long long val) {
    if (r < pos || pos < l) return;
    if (pos <= l && r <= pos) {
      f[k] += val;
      s[k] += val;
      return;
    }
    long long mid = (l + r) / 2;
    updateI(k * 2, l, mid, pos, val);
    updateI(k * 2 + 1, mid + 1, r, pos, val);
    f[k] = max(f[k * 2], f[k * 2 + 1]);
    s[k] = min(s[k * 2], s[k * 2 + 1]);
  }
  long long getMax(long long k, long long l, long long r, long long L,
                   long long R) {
    if (r < L || R < l) return -INF;
    if (L <= l && r <= R) return f[k];
    long long mid = (l + r) / 2;
    return max(getMax(k * 2, l, mid, L, R),
               getMax(k * 2 + 1, mid + 1, r, L, R));
  }
  long long getMin(long long k, long long l, long long r, long long L,
                   long long R) {
    if (r < L || R < l) return INF;
    if (L <= l && r <= R) return s[k];
    long long mid = (l + r) / 2;
    return min(getMin(k * 2, l, mid, L, R),
               getMin(k * 2 + 1, mid + 1, r, L, R));
  }
} IT11, IT10, IT01, IT00, IT0x, IT0y;
class BITx {
  long long f[100005];

 public:
  void update(long long i, long long val) {
    for (; i < 100005; i += i & -i) f[i] += val;
  }
  long long get(long long i) {
    long long ret = a[i];
    for (; i; i -= i & -i) ret += f[i];
    return ret;
  }
} BIT;
void update(long long i, long long dir) {
  if (i <= 1 || i >= n) return;
  if (dir == -1) {
    long long x = BIT.get(i - 1);
    long long y = BIT.get(i);
    long long z = BIT.get(i + 1);
    if (x <= y && y >= z)
      IT11.updateR(1, 1, n, i, -INF);
    else if (x <= y && y < z)
      IT10.updateR(1, 1, n, i, INF);
    else if (x > y && y >= z)
      IT01.updateR(1, 1, n, i, INF);
    else if (x > y && y < z) {
      IT00.updateR(1, 1, n, i, INF);
      IT0x.updateR(1, 1, n, i, INF);
      IT0y.updateR(1, 1, n, i, INF);
    }
  } else {
    long long x = BIT.get(i - 1);
    long long y = BIT.get(i);
    long long z = BIT.get(i + 1);
    if (x <= y && y >= z)
      IT11.updateR(1, 1, n, i, abs(y - z) + abs(y - x));
    else if (x <= y && y < z)
      IT10.updateR(1, 1, n, i, abs(y - z));
    else if (x > y && y >= z)
      IT01.updateR(1, 1, n, i, abs(y - x));
    else if (x > y && y < z) {
      IT00.updateR(1, 1, n, i, abs(y - z) + abs(y - x));
      IT0x.updateR(1, 1, n, i, abs(y - x));
      IT0y.updateR(1, 1, n, i, abs(y - z));
    }
  }
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  IT11.init(-INF);
  IT10.init(INF);
  IT01.init(INF);
  IT00.init(INF);
  IT0x.init(INF);
  IT0y.init(INF);
  cin >> n;
  for (long long i = 1; i <= n; i++) cin >> a[i];
  for (long long i = 2; i <= n; i++) curSum += abs(a[i] - a[i - 1]);
  for (long long i = 1; i <= n; i++) update(i, 1);
  long long Q;
  cin >> Q;
  for (long long q = 1; q <= Q; q++) {
    long long type;
    cin >> type;
    long long l, r, x;
    cin >> l >> r >> x;
    if (type == 1) {
      long long ans = -INF;
      if (l == 1)
        ans = max(ans, curSum - abs(BIT.get(1) - BIT.get(2)) +
                           abs(BIT.get(1) + x - BIT.get(2)));
      if (r == n)
        ans = max(ans, curSum - abs(BIT.get(n - 1) - BIT.get(n)) +
                           abs(BIT.get(n) + x - BIT.get(n - 1)));
      long long rec = IT11.getMax(1, 1, n, l, r);
      if (rec != -INF) ans = max(ans, curSum + 2 * x);
      rec = IT10.getMin(1, 1, n, l, r);
      if (rec != INF) {
        ans = max(ans, curSum);
        ans = max(ans, curSum + x - rec + (x - rec));
      }
      rec = IT01.getMin(1, 1, n, l, r);
      if (rec != INF) {
        ans = max(ans, curSum);
        ans = max(ans, curSum + x - rec + (x - rec));
      }
      rec = IT00.getMin(1, 1, n, l, r);
      ans = max(ans, curSum - rec + (2 * x - rec));
      ans = max(ans, curSum - 2 * x);
      rec = IT0x.getMin(1, 1, n, l, r);
      ans = max(ans, curSum - x - rec + (x - rec));
      rec = IT0y.getMin(1, 1, n, l, r);
      ans = max(ans, curSum - x - rec + (x - rec));
      cout << ans << '\n';
    } else {
      update(l - 1, -1);
      update(l, -1);
      update(r, -1);
      update(r + 1, -1);
      if (l != 1) curSum -= abs(BIT.get(l - 1) - BIT.get(l));
      if (r != n) curSum -= abs(BIT.get(r) - BIT.get(r + 1));
      BIT.update(l, x);
      BIT.update(r + 1, -x);
      if (l != 1) curSum += abs(BIT.get(l - 1) - BIT.get(l));
      if (r != n) curSum += abs(BIT.get(r) - BIT.get(r + 1));
      update(l - 1, 1);
      update(l, 1);
      update(r, 1);
      update(r + 1, 1);
    }
  }
}
