use std::fs::File;
use std::i32;
use std::io::{BufRead, BufReader, Write};

const MAX_N: usize = 6000001;
// const MAX_N: usize = 20;

fn main() {
    let mut input_array = vec![0; MAX_N];
    let mut partial_sums: Vec<i32> = vec![0; MAX_N];
    let mut coutfile = File::create("ssm.out").expect("Failed to create output file");

    let mut n = 0usize;

    // remove the memory overhead
    {
        let cinfile = File::open("ssm.in").expect("Failed to open input file");
        let mut cinfile = BufReader::new(cinfile);

        // index from 1!
        let mut first_line = String::new();
        cinfile
            .read_line(&mut first_line)
            .expect("Failed to read input");
        n = first_line.trim().parse::<usize>().unwrap();

        let mut second_line = String::new();
        cinfile
            .read_line(&mut second_line)
            .expect("Failed to read input");

        let mut temp_array = second_line
            .split_whitespace()
            .take(n)
            .map(|line| line.parse::<i32>().unwrap())
            .into_iter();

        for i in 1..=n {
            input_array[i] = temp_array.next().unwrap();
        }
    }

    // 1. Generate the array of partial sums corresponding to input_array
    let mut sum_1_to_j = 0;
    for j in 1..=n {
        sum_1_to_j += input_array[j];
        partial_sums[j] = sum_1_to_j;
    }

    // 2.
    let mut partial_sum_min = 0;
    let mut partial_sum_min_i = 0;
    let mut max_sum = i32::MIN;
    let mut max_sum_i = 0;
    let mut max_sum_j = 0;

    for j in 1..=n {
        let new_sum = partial_sums[j] - partial_sum_min;

        if new_sum > max_sum {
            max_sum = new_sum;
            max_sum_i = partial_sum_min_i + 1;
            max_sum_j = j;
        }

        if partial_sums[j] < partial_sum_min {
            partial_sum_min = partial_sums[j];
            partial_sum_min_i = j;
        }
    }

    writeln!(coutfile, "{} {} {}", max_sum, max_sum_i, max_sum_j).expect("Failed to write output");
}