Problem:
Score : 600 points

Problem Statement

Given is an integer sequence A_1, ..., A_N of length N.

We will choose exactly \left\lfloor \frac{N}{2} \right\rfloor elements from this sequence so that no two adjacent elements are chosen.

Find the maximum possible sum of the chosen elements.

Here \lfloor x \rfloor denotes the greatest integer not greater than x.

Constraints

2 \leq N \leq 2\times 10^5

|A_i|\leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 ... A_N

Output

Print the maximum possible sum of the chosen elements.

Sample Input 1

6
1 2 3 4 5 6

Sample Output 1

12

Choosing 2, 4, and 6 makes the sum 12, which is the maximum possible value.

Sample Input 2

5
-1000 -100 -10 0 10

Sample Output 2

0

Choosing -10 and 10 makes the sum 0, which is the maximum possible value.

Sample Input 3

10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 3

5000000000

Watch out for overflow.

Sample Input 4

27
18 -28 18 28 -45 90 -45 23 -53 60 28 -74 -71 35 -26 -62 49 -77 57 24 -70 -93 69 -99 59 57 -49

Sample Output 4

295

Solution in Rust (1.42.0) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use procontools::prelude::*;

fn main() {
    input! {
        n:usize,
        a:[i64;n]
    }

    let cuev = a
        .clone()
        .into_iter()
        .step_by(2)
        .acumulate(0, |x, y| x + y)
        .collect_vec();
    let cuod = a
        .clone()
        .into_iter()
        .skip(1)
        .step_by(2)
        .acumulate(0, |x, y| x + y)
        .collect_vec();
    if n <= 3 {
        p!(a.iter().max().unwrap());
        return;
    }
    if n % 2 == 0 {
        let a = (0..n / 2)
            .map(|x| cuod[n / 2] + cuev[x] - cuod[x])
            .max()
            .unwrap();
        let ans = a.max(cuev[n / 2]);
        p!(ans);
    } else {
        let mut dp = dp![std::i64::MIN+10i64.pow(10);n+100,3];
        // dbg!(dp.len());
        dp[0][0] = a[0];
        dp[1][1] = a[1];
        dp[2][2] = a[2];
        for i in 0..n - 2 {
            max_assign!(dp[i + 2][0], dp[i][0] + a[i + 2]);
            max_assign!(dp[i + 2][1], dp[i][1] + a[i + 2]);
            max_assign!(dp[i + 2][2], dp[i][2] + a[i + 2]);
            if i + 3 == n {
                continue;
            }
            max_assign!(dp[i + 3][1], dp[i][0] + a[i + 3]);
            max_assign!(dp[i + 3][2], dp[i][1] + a[i + 3]);
            if i + 4 == n {
                continue;
            }
            max_assign!(dp[i + 4][2], dp[i][0] + a[i + 4]);
        }
        // dbg!(&dp);
        p!(dp[n - 1][0].max(dp[n - 1][1]).max(dp[n - 1][2]))
    }
}
*/

fn main() {
    let exe = "/tmp/bin3D5D67F5";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";