import math

import queue

from collections import defaultdict



def readInt():

	return int(eval(input()))

def readInts():

	return list(map(int, input().split()))

def readChar():

	return eval(input())

def readChars():

	return input().split()

def factorization(n):

	res = []

	if n%2==0:

		res.append(2)

	for i in range(3,math.floor(n//2)+1,2):

		if n%i==0:

			c = 0

			for j in res:

				if i%j==0:

					c=1

			if c==0:

				res.append(i)

	return res

def fact2(n):

	p = factorization(n)

	res = []

	for i in p:

		c=0

		z=n

		while 1:

			if z%i==0:

				c+=1

				z/=i

			else:

				break

		res.append([i,c])

	return res

def fact(n):#階乗

	ans = 1

	m=n

	for _i in range(n-1):

		ans*=m

		m-=1

	return ans

def comb(n,r):#コンビネーション

	if n<r:

		return 0

	l = min(r,n-r)

	m=n

	u=1

	for _i in range(l):

		u*=m

		m-=1

	return u//fact(l)

def combmod(n,r,mod):

	return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod

def printQueue(q):

	r=qb

	ans=[0]*r.qsize()

	for i in range(r.qsize()-1,-1,-1):

		ans[i] = r.get()

	print(ans)

def dq():

	return queue.deque()

class UnionFind():

	def __init__(self, n):

		self.n = n

		self.parents = [-1]*n



	def find(self, x): # root

		if self.parents[x]<0:

			return x

		else:

			self.parents[x] = self.find(self.parents[x])

			return self.parents[x]



	def union(self,x,y):

		x = self.find(x)

		y = self.find(y)



		if x==y:

			return



		if self.parents[x]>self.parents[y]:

			x,y = y,x



		self.parents[x]+=self.parents[y]

		self.parents[y]=x



	def size(self,x):

		return -1*self.parents[self.find(x)]



	def same(self,x,y):

		return self.find(x)==self.find(y)



	def members(self,x): # much time

		root = self.find(x)

		return [i for i in range(self.n) if self.find(i)==root]



	def roots(self):

		return [i for i,x in enumerate(self.parents) if x<0]



	def group_count(self):

		return len(self.roots())



	def all_group_members(self):

		return {r: self.members(r) for r in self.roots()} # 1~n

def bitArr(n):#ビット全探索

	x = 1

	zero = "0"*n

	ans = []

	ans.append([0]*n)

	for i in range(2**n-1):

		ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))

		x+=1

	return ans;

def arrsSum(a1,a2):

	for i in range(len(a1)):

		a1[i]+=a2[i]

	return a1

def maxValue(a,b,v):

	v2 = v

	for i in range(v2,-1,-1):

		for j in range(v2//a+1): #j:aの個数

			k = i-a*j

			if k%b==0:

				return i

	return -1



n,k = readInts()

p = readInts()

#print(p)

maxValue = sum(p[0:k])

be = maxValue

memo = p[0:k]

ans = 0

for i in range(1,n-k+1):

	be+=-p[i-1]+p[i+k-1]

	if maxValue<be:

		maxValue = sum(p[i:i+k])

		memo = p[i:i+k]



for i in range(k):

	ans+=(memo[i]+1)/2



print(ans)
import math

import queue

from collections import defaultdict



def readInt():

	return int(eval(input()))

def readInts():

	return list(map(int, input().split()))

def readChar():

	return eval(input())

def readChars():

	return input().split()

def factorization(n):

	res = []

	if n%2==0:

		res.append(2)

	for i in range(3,math.floor(n//2)+1,2):

		if n%i==0:

			c = 0

			for j in res:

				if i%j==0:

					c=1

			if c==0:

				res.append(i)

	return res

def fact2(n):

	p = factorization(n)

	res = []

	for i in p:

		c=0

		z=n

		while 1:

			if z%i==0:

				c+=1

				z/=i

			else:

				break

		res.append([i,c])

	return res

def fact(n):#階乗

	ans = 1

	m=n

	for _i in range(n-1):

		ans*=m

		m-=1

	return ans

def comb(n,r):#コンビネーション

	if n<r:

		return 0

	l = min(r,n-r)

	m=n

	u=1

	for _i in range(l):

		u*=m

		m-=1

	return u//fact(l)

def combmod(n,r,mod):

	return (fact(n)/fact(n-r)*pow(fact(r),mod-2,mod))%mod

def printQueue(q):

	r=qb

	ans=[0]*r.qsize()

	for i in range(r.qsize()-1,-1,-1):

		ans[i] = r.get()

	print(ans)

def dq():

	return queue.deque()

class UnionFind():

	def __init__(self, n):

		self.n = n

		self.parents = [-1]*n



	def find(self, x): # root

		if self.parents[x]<0:

			return x

		else:

			self.parents[x] = self.find(self.parents[x])

			return self.parents[x]



	def union(self,x,y):

		x = self.find(x)

		y = self.find(y)



		if x==y:

			return



		if self.parents[x]>self.parents[y]:

			x,y = y,x



		self.parents[x]+=self.parents[y]

		self.parents[y]=x



	def size(self,x):

		return -1*self.parents[self.find(x)]



	def same(self,x,y):

		return self.find(x)==self.find(y)



	def members(self,x): # much time

		root = self.find(x)

		return [i for i in range(self.n) if self.find(i)==root]



	def roots(self):

		return [i for i,x in enumerate(self.parents) if x<0]



	def group_count(self):

		return len(self.roots())



	def all_group_members(self):

		return {r: self.members(r) for r in self.roots()} # 1~n

def bitArr(n):#ビット全探索

	x = 1

	zero = "0"*n

	ans = []

	ans.append([0]*n)

	for i in range(2**n-1):

		ans.append(list([int(x) for x in list((zero+bin(x)[2:])[-1*n:])]))

		x+=1

	return ans;

def arrsSum(a1,a2):

	for i in range(len(a1)):

		a1[i]+=a2[i]

	return a1

def maxValue(a,b,v):

	v2 = v

	for i in range(v2,-1,-1):

		for j in range(v2//a+1): #j:aの個数

			k = i-a*j

			if k%b==0:

				return i

	return -1



n,k = readInts()

p = readInts()



s = []

s.append((p[0]+1)/2)



for i in range(1,n):

	s.append(s[-1]+(p[i]+1)/2)



ans = s[k-1]

#print(s)

for i in range(n-k):

	ans = max(ans,s[i+k]-s[i])



print(ans)
import math
import queue
from collections import defaultdict


def readInt():
    return int(eval(input()))


def readInts():
    return list(map(int, input().split()))


def readChar():
    return eval(input())


def readChars():
    return input().split()


def factorization(n):
    res = []
    if n % 2 == 0:
        res.append(2)
    for i in range(3, math.floor(n // 2) + 1, 2):
        if n % i == 0:
            c = 0
            for j in res:
                if i % j == 0:
                    c = 1
            if c == 0:
                res.append(i)
    return res


def fact2(n):
    p = factorization(n)
    res = []
    for i in p:
        c = 0
        z = n
        while 1:
            if z % i == 0:
                c += 1
                z /= i
            else:
                break
        res.append([i, c])
    return res


def fact(n):  # 階乗
    ans = 1
    m = n
    for _i in range(n - 1):
        ans *= m
        m -= 1
    return ans


def comb(n, r):  # コンビネーション
    if n < r:
        return 0
    l = min(r, n - r)
    m = n
    u = 1
    for _i in range(l):
        u *= m
        m -= 1
    return u // fact(l)


def combmod(n, r, mod):
    return (fact(n) / fact(n - r) * pow(fact(r), mod - 2, mod)) % mod


def printQueue(q):
    r = qb
    ans = [0] * r.qsize()
    for i in range(r.qsize() - 1, -1, -1):
        ans[i] = r.get()
    print(ans)


def dq():
    return queue.deque()


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):  # root
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -1 * self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):  # much time
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}  # 1~n


def bitArr(n):  # ビット全探索
    x = 1
    zero = "0" * n
    ans = []
    ans.append([0] * n)
    for i in range(2**n - 1):
        ans.append(list([int(x) for x in list((zero + bin(x)[2:])[-1 * n :])]))
        x += 1
    return ans


def arrsSum(a1, a2):
    for i in range(len(a1)):
        a1[i] += a2[i]
    return a1


def maxValue(a, b, v):
    v2 = v
    for i in range(v2, -1, -1):
        for j in range(v2 // a + 1):  # j:aの個数
            k = i - a * j
            if k % b == 0:
                return i
    return -1


n, k = readInts()
p = readInts()
# print(p)
maxValue = sum(p[0:k])
be = maxValue
memo = p[0:k]
ans = 0
for i in range(1, n - k + 1):
    be += -p[i - 1] + p[i + k - 1]
    if maxValue < be:
        maxValue = sum(p[i : i + k])
        memo = p[i : i + k]
for i in range(k):
    ans += (memo[i] + 1) / 2
print(ans)

import math
import queue
from collections import defaultdict


def readInt():
    return int(eval(input()))


def readInts():
    return list(map(int, input().split()))


def readChar():
    return eval(input())


def readChars():
    return input().split()


def factorization(n):
    res = []
    if n % 2 == 0:
        res.append(2)
    for i in range(3, math.floor(n // 2) + 1, 2):
        if n % i == 0:
            c = 0
            for j in res:
                if i % j == 0:
                    c = 1
            if c == 0:
                res.append(i)
    return res


def fact2(n):
    p = factorization(n)
    res = []
    for i in p:
        c = 0
        z = n
        while 1:
            if z % i == 0:
                c += 1
                z /= i
            else:
                break
        res.append([i, c])
    return res


def fact(n):  # 階乗
    ans = 1
    m = n
    for _i in range(n - 1):
        ans *= m
        m -= 1
    return ans


def comb(n, r):  # コンビネーション
    if n < r:
        return 0
    l = min(r, n - r)
    m = n
    u = 1
    for _i in range(l):
        u *= m
        m -= 1
    return u // fact(l)


def combmod(n, r, mod):
    return (fact(n) / fact(n - r) * pow(fact(r), mod - 2, mod)) % mod


def printQueue(q):
    r = qb
    ans = [0] * r.qsize()
    for i in range(r.qsize() - 1, -1, -1):
        ans[i] = r.get()
    print(ans)


def dq():
    return queue.deque()


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):  # root
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -1 * self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):  # much time
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}  # 1~n


def bitArr(n):  # ビット全探索
    x = 1
    zero = "0" * n
    ans = []
    ans.append([0] * n)
    for i in range(2**n - 1):
        ans.append(list([int(x) for x in list((zero + bin(x)[2:])[-1 * n :])]))
        x += 1
    return ans


def arrsSum(a1, a2):
    for i in range(len(a1)):
        a1[i] += a2[i]
    return a1


def maxValue(a, b, v):
    v2 = v
    for i in range(v2, -1, -1):
        for j in range(v2 // a + 1):  # j:aの個数
            k = i - a * j
            if k % b == 0:
                return i
    return -1


n, k = readInts()
p = readInts()
s = []
s.append((p[0] + 1) / 2)
for i in range(1, n):
    s.append(s[-1] + (p[i] + 1) / 2)
ans = s[k - 1]
# print(s)
for i in range(n - k):
    ans = max(ans, s[i + k] - s[i])
print(ans)

-# print(p) -maxValue = sum(p[0:k]) -be = maxValue -memo = p[0:k] -ans = 0 -for i in range(1, n - k + 1): -    be += -p[i - 1] + p[i + k - 1] -    if maxValue < be: -        maxValue = sum(p[i : i + k]) -        memo = p[i : i + k] -for i in range(k): -    ans += (memo[i] + 1) / 2 +s = [] +s.append((p[0] + 1) / 2) +for i in range(1, n): +    s.append(s[-1] + (p[i] + 1) / 2) +ans = s[k - 1] +# print(s) +for i in range(n - k): +    ans = max(ans, s[i + k] - s[i])