import strutils
import sequtils
import algorithm
import math
import queues
import tables
import sets
import logging
import future
const INF* = int(1e18 + 373)
proc readSeq*(): seq[string] = stdin.readLine().strip().split()
proc readSeq*(n: Natural): seq[string] =
result = newSeq[string](n)
for i in 0..<n:
result[i] = stdin.readLine().strip()
proc readInt1*(): int = readSeq().map(parseInt)[0]
proc readInt2*(): (int, int) =
let a = readSeq().map(parseInt)
return (a[0], a[1])
proc readInt3*(): (int, int, int) =
let a = readSeq().map(parseInt)
return (a[0], a[1], a[2])
proc readInt4*(): (int, int, int, int) =
let a = readSeq().map(parseInt)
return (a[0], a[1], a[2], a[3])
type seq2*[T] = seq[seq[T]]
proc newSeq2*[T](n1, n2: Natural): seq2[T] = newSeqWith(n1, newSeq[T](n2))
#------------------------------------------------------------------------------#
type Op2[T] = proc(a, b: T): T
type SegmentTree[T] = tuple[ n: int, a: seq[T], e: T, f: Op2[T] ]
proc initSegmentTree[T](n: int, e: T, f: Op2[T]): SegmentTree[T] =
var m = 1
while m < n:
m *= 2
var a = newSeq[T](2 * m)
a.fill(e)
return (m, a, e, f)
proc update[T](this: var SegmentTree[T], i: int, x: T) =
this.a[this.n + i] = x
var j = (this.n + i) div 2
while j > 0:
this.a[j] = this.f(this.a[j * 2], this.a[j * 2 + 1])
j = j div 2
proc query[T](this: SegmentTree[T], s, t, i, ll, hh: int): T =
if t <= ll or hh <= s:
return this.e
if s <= ll and hh <= t:
return this.a[i]
let m = (ll + hh) div 2
let vl = this.query(s, t, i * 2, ll, m)
let vh = this.query(s, t, i * 2 + 1, m, hh)
return this.f(vl, vh)
proc query[T](this: SegmentTree[T], s, t: int): T = query(this, s, t, 1, 0, this.n)
#------------------------------------------------------------------------------#
proc main() =
let (n, m, k) = readInt3()
let a = readSeq().map(parseInt)
var dp = newSeq2[int](n, k)
for j in 1..<k:
dp[0][j] = -INF
var segtree = initSegmentTree[int](n, -INF, (a: int, b: int) => max(a, b))
for j in 1..<k:
for i in 0..<n:
let v = dp[i][j - 1]
segtree.update(i, if v <= -INF: -INF else: v + j * a[i])
for i in 1..<n:
dp[i][j] = segtree.query(max(i - m, 0), i)
var ans = 0
for i in 0..<n:
if dp[i][k - 1] <= -INF:
continue
ans = max(ans, dp[i][k - 1] + k * a[i])
echo ans
main()