Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
)

func main() {
	parseProblem(os.Stdin)
}

func parseProblem(r io.Reader) {
	const (
		initialBufSize = 100000
		maxBufSize     = 1000000
	)
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords) // bufio.ScanLines
	for true {
		n, k := scanInt(sc), scanInt(sc)
		if n == 0 && k == 0 {
			break
		}
		sum := make([]int, n+2)
		for i := 2; i <= n+1; i++ {
			sum[i] = sum[i-1] + scanInt(sc)
		}
		max := math.MinInt32
		for i := 1; i+k <= n+1; i++ {
			if v := sum[i+k] - sum[i]; max < v {
				max = v
			}
		}
		fmt.Println(max)
	}
	return
}

func resolve(n int) int {
	return n
}

// snip-scan-funcs
func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return int(i)
}
func scanString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

C++: #include <vector>
#include <cstdint>

using namespace std;

using lint=int64_t;
using uint=uint32_t;
using ulint=uint64_t;

template<class T>
using vector2d=vector<vector<T>>;

template<class T>
struct CumulativeSum2D{
  vector2d<T> cum;

  CumulativeSum2D(const vector2d<T>& data):cum(data.size(), vector<T>(data[0].size(),0)){
    cum[0][0]=data[0][0];
    for(int r=1;r<data.size();r++){
      cum[r][0]=cum[r-1][0]+data[r][0];
    }
    for(int c = 1; c < data[0].size(); ++c){
      cum[0][c]=cum[0][c-1]+data[0][c];
    }
    for(int r = 1; r < data.size(); ++r){
      for(int c = 1; c < data[0].size(); ++c){
        cum[r][c]=cum[r-1][c]+cum[r][c-1]-cum[r-1][c-1]+data[r][c];
      }
    }
  }


  /// \return 2頂点が(sr,sc)と(gr,gc)であるような矩形内の和(2頂点を含む)
  T Query(int sr, int sc, int gr, int gc){
    T result=cum[gr][gc];
    if(sr-1>=0){
      result-=cum[sr-1][gc];
    }
    if(sc-1>=0){
      result-=cum[gr][sc-1];
    }
    if(sr-1>=0&&sc-1>=0){
      result+=cum[sr-1][sc-1];
    }
    return result;
  }
};

template<class T>
struct CumulativeSum1D{
  vector<T> cum;

  CumulativeSum1D(const vector<T>& data):cum(data.size(),0){
    cum[0]=data[0];
    for(int i = 1; i < data.size(); ++i){
      cum[i]=cum[i-1]+data[i];
    }
  }


  /// \return 区間[l,r]の和
  T Query(int l, int r){
    return (l>0)?cum[r]-cum[l-1]:cum[r];
  }
};



//verify

#include <iostream>

template<class T>
bool UpdateMax(T &a, const T &b){
  if(a<b){
    a=b;
    return true;
  }else{
    return false;
  }
}

template<class T>
bool UpdateMin(T &a, const T &b){
  if(a>b){
    a=b;
    return true;
  }else{
    return false;
  }
}

// int main(){
//   int n;
//   cin>>n;
//   vector2d<lint> a(n, vector<lint>(n, 0));
//   for(int i = 0; i < n; ++i){
//     for(int j = 0; j < n; ++j){
//       cin>>a[i][j];
//     }
//   }
//
//   CumulativeSum2D<lint> cum(a);
//   lint result=INT64_MIN/2;
//
//   for(int sr = 0; sr < n; ++sr){
//     for(int sc = 0; sc < n; ++sc){
//       for(int gr = sr; gr < n; ++gr){
//         for(int gc = sc; gc < n; ++gc){
//           UpdateMax(result,cum.Query(sr,sc,gr,gc));
//         }
//       }
//     }
//   }
//
//   cout<<result<<endl;
//
// }

int main(){
  while(true){
    int n,k;
    cin>>n>>k;
    if(n==0) break;

    vector<lint> a(n);
    for(int i = 0; i < n; ++i){
      cin>>a[i];
    }
    CumulativeSum1D<lint> cum(a);
    lint result=INT64_MIN;
    for(lint l=0;l<n;l++){
      lint r=l+k-1;
      if(r>=n) break;
      UpdateMax(result,cum.Query(l,r));
    }
    cout<<result<<endl;
  }


}

C++: #include <iostream>
#include <vector>
using namespace std;

int main(){
  int serchn,numn;
  int gh = 0;
  vector<int> outp;
  for(int a = 0;;a++){
    cin >> numn >> serchn;
    if(numn == 0 && serchn == 0)break;
    outp.resize(a+1);
    vector<int> num(numn);
    for(int n = 0;n<serchn-1;n++){
      cin >> num[n];
      gh += num[n];
    }
    for(int n = serchn - 1;n<numn;n++){
      cin >> num[n];
      gh += num[n];
      if(outp[a] < gh)outp[a] = gh;
      gh -= num[n-serchn+1];
    }
  }
  for(int b = 0;b<outp.size();b++){
    cout << outp[b] << endl;
  }
  return 0;
}

C++: #include<iostream>
#include<algorithm>
using namespace std;

int main(){

  int n,k;

  while(cin >> n >> k, n, k){

    int a[100000] = {0},z = 0,x = 0;

    for(int i=0;i<n;i++) cin >> a[i];

    for(int i=0;i<k;i++) z += a[i];
    x = z;
    for(int i=k;i<n;i++){
      x += (a[i] - a[i-k]);
      z = max(z , x);
    }

    cout << z << endl; 
  }
}

C++: #include<iostream>
using namespace std;


int main(){
  int n, k;
  int a[100100];
  int b[100100];
  for(;;){
    cin >> n >> k;
    if(n==0 && k==0) break;
    
    for(int i=0; i<n; i++){
      cin >> a[i];
    }
    b[0] = 0;
    for(int i=0; i<n; i++){
      b[i+1] = b[i] + a[i];
    }
    int mx = -100000;
    for(int i=0; i<n-k; i++){
      int s = b[i+k+1] - b[i];
      if(mx < s) mx = s;
    }
    cout << mx << endl;
  }
  return 0;
}

C++: #include<iostream>
#include<vector>
using namespace std;

int main(){
    int n, k;
    while(cin >>n >>k){
        if(n == 0 && k == 0) break;
        vector<int> vec;
        int max = 0, now = 0;
        for(int i = 0; i < k; i++){
            int tmp;
            cin >>tmp;
            max += tmp;
            now += tmp;
            vec.push_back(tmp);
        }
        for(int i = k; i < n; i++){
            int tmp;
            cin >>tmp;
            vec.push_back(tmp);
            now += tmp;
            now -= vec[i - k];
            if(max < now) max = now;
        }
        cout <<max <<endl;
    }
    return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;
using ll = long long;
const int INF = 999999999;

int main() {
    int N, K;
    while(cin >> N >> K) {
        if(N == 0) break;
        vector<ll> a(N);
        for(int i = 0; i < N; ++i) cin >> a[i];

        vector<int> s(N+1, 0);
        for(int i = 0; i < N; ++i) s[i+1] = s[i] + a[i];

        ll res = -INF;
        for(int i = 0; i <= N-K; ++i) {
            ll val = s[K+i] - s[i];
            if(res < val) res = val;
        }
        cout << res << endl;
    }

}

C++: #include<bits/stdc++.h>
using namespace std;
int main(){
    int n,k;
    cin>>n>>k;
    vector<int> vec(n);
    for(int i=0;i<n;i++){
        cin>>vec.at(i);
    }
    vector<int> rsw(n+1);
    rsw.at(0)=0;
    for(int i=1;i<n+1;i++){
        rsw.at(i) = rsw.at(i-1) + vec.at(i-1);
    }
    int ans =0;
    for(int i=k;i<n+1;i++){
        if(ans < rsw.at(i) - rsw.at(i-k)){
            ans = rsw.at(i) - rsw.at(i-k);
        }
    }
    cout << ans << endl;
}

C++: #include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
    int n,k;
    for(;;){
        scanf("%d%d",&n,&k);
        if(n==0&&k==0)break;
        int ma=0,now=0;
        vector<int> ins(n);
        for(int i=0;i<n;i++)scanf("%d",&ins[i]);
        for(int i=0;i<k;i++)now+=ins[i];
        for(int i=k;i<n;i++){
            now+=ins[i]-ins[i-k];
            ma=max(ma,now);
        }
        printf("%d\n",ma);
    }
}