#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;
#[allow(unused_imports)]
use std::io::*;
#[allow(unused_imports)]
use std::iter;
#[allow(unused_imports)]
use std::mem::*;
#[allow(unused_imports)]
use std::str::*;
#[allow(unused_imports)]
use std::usize;

#[allow(unused_macros)]
macro_rules! read_cols {
    ($($t:ty),+) => {{
        let mut line = String::new();
        stdin().read_line(&mut line).unwrap();

        let mut it = line.trim()
            .split_whitespace();

        ($(
            it.next().unwrap().parse::<$t>().ok().unwrap()
        ),+)
    }}
}

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let mut line = String::new();
    stdin().read_line(&mut line).unwrap();
    line.trim().to_string().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vecl<T: FromStr>(n: usize) -> Vec<T> {
    let mut v = vec![];
    for _ in 0..n {
        v.push(read::<T>());
    }

    v
}

#[allow(dead_code)]
fn read_vec<T: FromStr>() -> Vec<T> {
    let mut line = String::new();
    stdin().read_line(&mut line).unwrap();

    line.trim()
        .split_whitespace()
        .map(|s| s.parse().ok().unwrap())
        .collect()
}

fn main() {
    let (n, k) = read_cols!(usize, usize);
    let a = read_vec::<i64>();

    let ls: Vec<_> = iter::once(0).chain(a.iter().cloned()).scan(0, |s, aa| {
        if aa > 0 {
            *s += aa;
        }
        Some(*s)
    }).collect();

    let rs: Vec<_> = a.iter().cloned().chain(iter::once(0)).rev().scan(0, |s, aa| {
        if aa > 0 {
            *s += aa;
        }
        Some(*s)
    }).collect();

    let ans = (0..n - k + 1).map(|i| (i, i + k)).map(|(l, r)| {
        let s: i64 = a.iter().skip(l).take(k).sum();
        if s > 0 {
            ls[l] + rs[n - r] + s
        } else {
            ls[l] + rs[n - r]
        }
    }).max().unwrap();

    println!("{}", ans);
}
