#include <bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
typedef long long ll;
typedef pair<ll, int> pii;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;

int a[maxn], n;

template <class T>
T max(const T &a, const T &b, const T &c)
{
  return max(a, max(b, c));
}
struct Node
{
  ll sum, pmx, lmx, rmx, lpmx, prmx;
  int p, l, r, lp, rp;
  friend Node operator+(const Node &a, const Node &b)
  {
    Node c;
    c.sum = a.sum + b.sum;
    tie(c.pmx, c.p) = max(pii(a.pmx, a.p), pii(b.pmx, b.p));
    tie(c.lmx, c.l) = max(pii(a.lmx, a.l), pii(a.sum + b.lmx, b.l));
    tie(c.rmx, c.r) = max(pii(b.rmx, b.r), pii(b.sum + a.rmx, a.r));
    tie(c.lpmx, c.lp) = max(pii(a.lpmx, a.lp), pii(a.lmx + b.pmx, b.p), pii(a.sum + b.lpmx, b.lp));
    tie(c.prmx, c.rp) = max(pii(b.prmx, b.rp), pii(b.rmx + a.pmx, a.p), pii(b.sum + a.prmx, a.rp));
    return c;
  }
} tr[maxn << 2];

struct Ans
{
  ll v;
  int x, y;
  bool operator<(const Ans &o) const
  {
    return v < o.v;
  }
} ans;

void pushUp(int rt)
{

  tr[rt] = tr[lson] + tr[rson];
}

void build(int l, int r, int rt)
{

  if (l == r)
  {
    tr[rt].sum = tr[rt].pmx = tr[rt].lpmx = tr[rt].prmx = a[l];
    tie(tr[rt].lmx, tr[rt].l) = max(pii(a[l], l), pii(0, l - 1));
    tie(tr[rt].rmx, tr[rt].r) = max(pii(a[r], r), pii(0, r + 1));
    tr[rt].p = tr[rt].lp = tr[rt].rp = l;
    return;
  }
  int mid = gmid;
  build(l, mid, lson);
  build(mid + 1, r, rson);
  pushUp(rt);
}

Node query(int l, int r, int rt, int L, int R)
{

  // cout << rt << " " << l << " ?? " << r << " " << tr[rt].prmx << " " << tr[rt].rp << endl;
  if (l >= L && r <= R)
    return tr[rt];
  int mid = gmid;
  if (L <= mid && R > mid)
    return query(l, mid, lson, L, R) + query(mid + 1, r, rson, L, R);
  else if (L <= mid)
    return query(l, mid, lson, L, R);
  else
    return query(mid + 1, r, rson, L, R);
}

int main()
{

  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n;
  for (int i = 1; i <= n; ++i)
    cin >> a[i];
  build(1, n, 1);
  Ans ans = Ans{a[1], 1, 1};
  for (int i = 1; i <= n; ++i)
  {
    Node ln = i > 1 ? query(1, n, 1, 1, i - 1) : Node();
    Node rn = i < n ? query(1, n, 1, i + 1, n) : Node();
    if (i > 1)
      ans = max(ans, Ans{ln.rmx + a[i], i, ln.r});
    if (i > 1)
      ans = max(ans, Ans{ln.prmx + rn.lmx, ln.rp, i});
    if (i < n)
      ans = max(ans, Ans{ln.rmx + rn.lpmx, i, rn.lp});
    // if(i == 4) cout << ln.prmx << " ?? " << ln.rp << endl;
    // cout << i << " " << ans.v << " " << ans.x << " " << ans.y << endl;
  }
  if (ans.x == ans.y)
    ans.x = 1, ans.y = n;
  cout << ans.v << endl;
  cout << ans.x << " " << ans.y;
  return 0;
}