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 proconio::{fastout, input};
use std::cmp::max;

fn solve(a: &[i64]) -> Vec<i64> {
    let n = a.len();
    let mut dp = vec![0i64; n];
    let mut no_skip = vec![0i64; n];

    for i in 0..n {
        if i % 2 == 0 {
            dp[i] = a[i];
            no_skip[i] = a[i];
            if i >= 2 {
                dp[i] += dp[i - 2];
                no_skip[i] += no_skip[i - 2];
            }
        } else {
            let add = if i >= 2 { dp[i - 2] } else { 0 };
            let add_skip = if i >= 3 { no_skip[i - 3] } else { 0 };
            dp[i] = a[i] + max(add, add_skip);
        }
    }

    dp
}

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

    let lef = solve(&a);
    a.reverse();
    let rig = {
        let mut r = solve(&a);
        r.reverse();
        r
    };

    if n % 2 == 0 {
        println!("{}", max(lef[n - 1], lef[n - 2]));
    } else {
        let mut res = max(lef[n - 2], lef[n - 1]);
        for i in 0..n - 1 {
            let l = if i == 0 {
                0i64
            } else if i % 2 == 1 {
                lef[i - 1]
            } else {
                max(lef[i - 1], lef[i - 2])
            };
            let r = if i == n - 2 {
                0i64
            } else if (n - i - 2) % 2 == 1 {
                rig[i + 2]
            } else {
                max(rig[i + 2], rig[i + 3])
            };
            res = max(res, l + r);
        }
        println!("{}", res);
    }
}

*/

fn main() {
    let exe = "./binXXXXXX";
    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>";