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

const MAX_N: usize = 6000001;
// const MAX_N: usize = 20;
struct Solution {
    i_sp_min: usize,
    j: usize,
    sum: i32,
}

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

    let mut n = 0usize;

    let mut solution = Solution {
        i_sp_min: 0,
        j: 0,
        sum: i32::MIN,
    };

    // 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];
        sp_array[j] = sum_1_to_j;
    }

    // 2.
    let mut current_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 = sp_array[j] - current_partial_sum_min;

        if new_sum > solution.sum {
            solution.sum = new_sum;
            solution.j = j;
        }

        if sp_array[j] < current_partial_sum_min {
            current_partial_sum_min = sp_array[j];
            solution.i_sp_min = j;
        }
    }

    writeln!(
        coutfile,
        "{} {} {}",
        solution.sum,
        solution.i_sp_min + 1,
        solution.j
    )
    .expect("Failed to write output");
}