import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.concurrency;
import std.traits;
import std.uni;
import core.bitop : popcnt;
alias Generator = std.concurrency.Generator;

enum long INF = long.max/3;
enum long MOD = 10L^^9+7;

void main() {
  long N, M, K;
  scanln(N, M, K);
  long[] as = readln.split.to!(long[]);

  long[][] dp = new long[][](2, N+1);

  foreach(j; 1..K+1) {
    dp[j%2][] = -INF;
    long[] xs = dp[(j-1)%2][0..N];
    size_t[] ys = xs.slideMinimum!(long, "a>b")(M);
    foreach(i; 0..N) {
      dp[j%2][i+1] = xs[ys[i]] + j*as[i];
    }
  }
  dp[K%2].reduce!max.writeln;
}

// スライド最小値/最大値 O(n+k)
//   fun = "a<b" => ys[i] := argmin(xs[max(0, i+1-k)..min(n, i+1)])
//   fun = "a>b" => ys[i] := argmax(xs[max(0, i+1-k)..min(n, i+1)])
size_t[] slideMinimum(T, alias fun = "a<b")(T[] xs, size_t k)
if(is(typeof(binaryFun!fun(T.init, T.init)) == bool)) in {
  assert(k > 0);
} body {
  size_t n = xs.length;
  auto deq = Deque!size_t();
  deq.reserveBack(n);
  size_t[] ys = new size_t[n+k-1];
  foreach(i; 0..n+k-1) {
    if (i < n) {
      while(!deq.empty && !binaryFun!fun(xs[deq.back], xs[i])) {
        deq.removeBack;
      }
      deq.insertBack(i);
    }
    ys[i] = deq.front;
    if (deq.front+k == i+1) {
      deq.removeFront;
    }
  }
  assert(deq.empty);
  return ys;
}

// Deque - implemented in dynamic arrays

struct Deque(T) {
  import std.range, std.algorithm, std.conv, std.format;

private:
  T[] frontData = [];
  T[] backData = [];
  size_t frontSize = 0;
  size_t backSize = 0;

  // [frontIndex, backIndex)
  ptrdiff_t frontIndex = 0;
  ptrdiff_t backIndex = 0;

public:

  this(T[] data) {
    this([], data, 0, cast(ptrdiff_t)data.length, false);
  }

  bool empty() @property {
    return frontIndex == backIndex;
  }

  size_t length() @property {
    return cast(size_t) (backIndex - frontIndex);
  }

  void clear() {
    frontIndex = backIndex = 0;
    frontData = [];
    backData = [];
    frontSize = 0;
    backSize = 0;
  }

  ref T front() @property in {
    assert(!empty, "Attempting to get the front of an empty Deque");
  } body {
    return this[0];
  }

  ref T front(T value) @property in {
    assert(!empty, "Attempting to assign to the front of an empty Deque");
  } body {
    return this[0] = value;
  }

  ref T back() @property in {
    assert(!empty, "Attempting to get the back of an empty Deque");
  } body {
    return this[$-1];
  }

  ref T back(T value) @property in {
    assert(!empty, "Attempting to assign to the back of an empty Deque");
  } body {
    return this[$-1] = value;
  }

  void insertFront(T value) {
    if (frontIndex>0) {
      backData[frontIndex - 1] = value;
    } else {
      if (frontSize + 1 >= frontData.length) {
        resizeFront();
      }
      frontData[frontSize++] = value;
    }
    frontIndex--;
  }

  void insertBack(T value) {
    if (backIndex < 0) {
      frontData[-backIndex - 1] = value;
    } else {
      if (backSize + 1 >= backData.length) {
        resizeBack();
      }
      backData[backSize++] = value;
    }
    backIndex++;
  }

  void removeFront() in {
    assert(!empty, "Attempting to remove the front of an empty Deque");
  } body {
    if (frontIndex >= 0) {
      // do nothing
    } else {
      assert(frontSize > 0);
      frontSize--;
    }
    frontIndex++;
  }
  alias popFront = removeFront;

  void removeBack() in {
    assert(!empty, "Attempting to remove the back of an empty Deque");
  } body {
    if (backIndex <= 0) {
      // do nothing
    } else {
      assert(backSize > 0);
      backSize--;
    }
    backIndex--;
  }
  alias popBack = removeBack;

  typeof(this) save() @property {
    return typeof(this)(frontData, backData, frontIndex, backIndex, true);
  }

  void reserveFront(size_t num) {
    frontData.length = max(frontData.length, num);
  }

  void reserveBack(size_t num) {
    backData.length = max(backData.length, num);
  }

  // xs ~= value
  typeof(this) opOpAssign(string op)(T value) if (op == "~") {
    this.insertBack(value);
    return this;
  }

  // xs[index]
  ref T opIndex(size_t index) in {
    assert(0<=index && index<length, "Access violation");
  } body {
    ptrdiff_t _index = frontIndex + (cast(ptrdiff_t)index);
    return _index>=0 ? backData[_index] : frontData[-_index - 1];
  }

  // xs[indices[0] .. indices[1]]
  typeof(this) opIndex(size_t[2] indices) in {
    assert(0<=indices[0] && indices[1]<=length, "Access violation");
  } body {
    return typeof(this)(frontData, backData, frontIndex + cast(ptrdiff_t)indices[0], frontIndex + cast(ptrdiff_t)indices[1], false);
  }

  // xs[]
  typeof(this) opIndex() {
    return this;
  }

  // xs[index] = value
  ref T opIndexAssign(T value, size_t index) in {
    assert(0<=index && index<length, "Access violation");
  } body {
    ptrdiff_t _index = (cast(ptrdiff_t)index) - frontIndex;
    return (_index>=0 ? backData[_index] : frontData[-_index - 1]) = value;
  }

  // xs[indices[0] .. indices[1]] = value
  typeof(this) opIndexAssign(T value, size_t[2] indices) in {
    assert(0<=indices[0] && indices[1]<=length, "Access violation");
  } body {
    ptrdiff_t _frontIndex = frontIndex + (cast(ptrdiff_t) indices[0]);
    ptrdiff_t _backIndex = frontIndex + (cast(ptrdiff_t) indices[1]);
    frontData[clamp(-_backIndex, 0, frontSize)..clamp(-_frontIndex, 0, frontSize)] = value;
    backData[clamp(_frontIndex, 0, backSize)..clamp(_backIndex, 0, backSize)] = value;
    return this;
  }

  // xs[] = value
  typeof(this) opIndexAssign(T value) {
    backData[0..backSize] = value;
    frontData[0..frontSize] = value;
    return this;
  }

  // xs[indices[0] .. indices[1]] op= value
  typeof(this) opIndexOpAssign(string op)(T value, size_t[2] indices) in {
    assert(0<=indices[0] && indices[1]<=length, "Access violation");
  } body {
    ptrdiff_t _frontIndex = frontIndex + (cast(ptrdiff_t) indices[0]);
    ptrdiff_t _backIndex = frontIndex + (cast(ptrdiff_t) indices[1]);
    mixin(q{
      frontData[clamp(-_backIndex, 0, frontSize)..clamp(-_frontIndex, 0, frontSize)] %s= value;
    }.format(op));
    mixin(q{
      backData[clamp(_frontIndex, 0, backSize)..clamp(_backIndex, 0, backSize)] %s= value;
    }.format(op));
    return this;
  }

  // xs[] op= value
  typeof(this) opIndexOpAssign(string op)(T value) {
    mixin(q{
      frontData[0..frontSize] %s= value;
    }.format(op));
    mixin(q{
      backData[0..backSize] %s= value;
    }.format(op));
    return this;
  }

  // $
  size_t opDollar(size_t dim: 0)() {
    return length;
  }

  // i..j
  size_t[2] opSlice(size_t dim: 0)(size_t i, size_t j) in {
    assert(0<=i && j<=length, "Access violation");
  } body {
    return [i, j];
  }

  bool opEquals(S: T)(Deque!S that) {
    if (this.length != that.length) return false;
    foreach(i; 0..this.length) {
      if (this[i] != that[i]) return false;
    }
    return true;
  }

  bool opEquals(S: T)(S[] that) {
    if (this.length != that.length) return false;
    foreach(i; 0..this.length) {
      if (this[i] != that[i]) return false;
    }
    return true;
  }

  string toString() const {
    auto xs = frontData[clamp(-backIndex, 0, frontSize)..clamp(-frontIndex, 0, frontSize)];
    auto ys = backData[clamp(frontIndex, 0, backSize)..clamp(backIndex, 0, backSize)];
    return "Deque(%s)".format(xs.retro.array ~ ys);
  }

private:
  this(T[] frontData, T[] backData, ptrdiff_t frontIndex, ptrdiff_t backIndex, bool shouldDuplicate) {
    this.frontSize = frontData.length;
    this.backSize = backData.length;
    this.frontData = shouldDuplicate ? frontData.dup : frontData[0..clamp(-frontIndex, 0, $)];
    this.backData = shouldDuplicate ? backData.dup : backData[0..clamp(backIndex, 0, $)];
    this.frontIndex = frontIndex;
    this.backIndex = backIndex;
  }

  void resizeFront() {
    frontData.length = max(frontSize * 2, 1);
  }

  void resizeBack() {
    backData.length = max(backSize * 2, 1);
  }

  invariant {
    assert(frontSize <= frontData.length);
    assert(backSize <= backData.length);
    assert(-frontIndex <= cast(ptrdiff_t)frontSize);
    assert(frontIndex <= backIndex);
    assert(backIndex <= cast(ptrdiff_t)backSize);
  }
}

@safe pure unittest {
  // Deque should be Range
  import std.range;
  assert(isInputRange!(Deque!long));
  assert(isOutputRange!(Deque!long, int));
  assert(isOutputRange!(Deque!long, long));
  assert(isForwardRange!(Deque!long));
  assert(isBidirectionalRange!(Deque!long));
  assert(isRandomAccessRange!(Deque!long));
}

@safe pure unittest {
  // test basic operations

  Deque!long xs = [1, 2, 3]; // == Deque!long([1, 2, 3])
  assert(xs.length == 3);
  assert(xs.front == 1 && xs.back == 3);
  assert(xs[0] == 1 && xs[1] == 2 && xs[2] == 3);
  assert(xs == [1, 2, 3]);

  size_t i = 0;
  foreach(x; xs) {
    assert(x == ++i);
  }

  xs.front = 4;
  xs[1] = 5;
  xs.back = 6;
  assert(xs == [4, 5, 6]);

  xs.removeBack;
  xs.removeBack;
  assert(xs == [4]);
  xs.insertFront(3);
  xs.insertFront(2);
  xs.insertFront(1);
  assert(xs == [1, 2, 3, 4]);
  xs.insertBack(5);
  xs ~= 6;
  assert(xs == [1, 2, 3, 4, 5, 6]);
  xs.removeFront;
  assert(xs == [2, 3, 4, 5, 6]);

  xs.clear;
  assert(xs.empty);
  xs.insertBack(1);
  assert(!xs.empty);
  assert(xs == [1]);
  xs[0]++;
  assert(xs == [2]);
}

@safe pure unittest {
  // test slicing operations

  Deque!long xs = [1, 2, 3];
  assert(xs[] == [1, 2, 3]);
  assert((xs[0..2] = 0) == [0, 0, 3]);
  assert((xs[0..2] += 1) == [1, 1, 3]);
  assert((xs[] -= 2) == [-1, -1, 1]);

  Deque!long ys = xs[0..2];
  assert(ys == [-1, -1]);
  ys[0] = 5;
  assert(ys == [5, -1]);
  assert(xs == [5, -1, 1]);
}

@safe pure unittest {
  // test using phobos
  import std.algorithm, std.array;
  Deque!long xs = [10, 5, 8, 3];
  assert(xs.sort!"a<b".equal([3, 5, 8, 10]));
  Deque!long ys = xs.sort!"a<b".array;
  assert(ys == [3, 5, 8, 10]);
}

@safe pure unittest {
  // test different types of equality

  int[] xs = [1, 2, 3];
  Deque!int ys = [1, 2, 3];
  Deque!long zs = [1, 2, 3];
  assert(xs == ys);
  assert(xs == zs);
  assert(ys == zs);

  ys.removeFront;
  assert(ys != zs);
  ys.insertFront(1);
  assert(ys == zs);
}


// ----------------------------------------------


void times(alias fun)(long n) {
  // n.iota.each!(i => fun());
  foreach(i; 0..n) fun();
}
auto rep(alias fun, T = typeof(fun()))(long n) {
  // return n.iota.map!(i => fun()).array;
  T[] res = new T[n];
  foreach(ref e; res) e = fun();
  return res;
}

T ceil(T)(T x, T y) if (isIntegral!T || is(T == BigInt)) {
  // `(x+y-1)/y` will only work for positive numbers ...
  T t = x / y;
  if (t * y < x) t++;
  return t;
}

T floor(T)(T x, T y) if (isIntegral!T || is(T == BigInt)) {
  T t = x / y;
  if (t * y > x) t--;
  return t;
}

ref T ch(alias fun, T, S...)(ref T lhs, S rhs) {
  return lhs = fun(lhs, rhs);
}
unittest {
  long x = 1000;
  x.ch!min(2000);
  assert(x == 1000);
  x.ch!min(3, 2, 1);
  assert(x == 1);
  x.ch!max(100).ch!min(1000); // clamp
  assert(x == 100);
  x.ch!max(0).ch!min(10); // clamp
  assert(x == 10);
}

mixin template Constructor() {
  import std.traits : FieldNameTuple;
  this(Args...)(Args args) {
    // static foreach(i, v; args) {
    foreach(i, v; args) {
      mixin("this." ~ FieldNameTuple!(typeof(this))[i]) = v;
    }
  }
}

void scanln(Args...)(auto ref Args args) {
  import std.meta;
  template getFormat(T) {
    static if (isIntegral!T) {
      enum getFormat = "%d";
    } else static if (isFloatingPoint!T) {
      enum getFormat = "%g";
    } else static if (isSomeString!T || isSomeChar!T) {
      enum getFormat = "%s";
    } else {
      static assert(false);
    }
  }
  enum string fmt = [staticMap!(getFormat, Args)].join(" ");
  string[] inputs = readln.chomp.split;
  foreach(i, ref v; args) {
    v = inputs[i].to!(Args[i]);
  }
}

// fold was added in D 2.071.0
static if (__VERSION__ < 2071) {
  template fold(fun...) if (fun.length >= 1) {
    auto fold(R, S...)(R r, S seed) {
      static if (S.length < 2) {
        return reduce!fun(seed, r);
      } else {
        return reduce!fun(tuple(seed), r);
      }
    }
  }
}

// cumulativeFold was added in D 2.072.0
static if (__VERSION__ < 2072) {
  template cumulativeFold(fun...)
  if (fun.length >= 1)
  {
    import std.meta : staticMap;
    private alias binfuns = staticMap!(binaryFun, fun);

    auto cumulativeFold(R)(R range)
    if (isInputRange!(Unqual!R))
    {
      return cumulativeFoldImpl(range);
    }

    auto cumulativeFold(R, S)(R range, S seed)
    if (isInputRange!(Unqual!R))
    {
      static if (fun.length == 1)
        return cumulativeFoldImpl(range, seed);
      else
        return cumulativeFoldImpl(range, seed.expand);
    }

    private auto cumulativeFoldImpl(R, Args...)(R range, ref Args args)
    {
      import std.algorithm.internal : algoFormat;

      static assert(Args.length == 0 || Args.length == fun.length,
        algoFormat("Seed %s does not have the correct amount of fields (should be %s)",
          Args.stringof, fun.length));

      static if (args.length)
        alias State = staticMap!(Unqual, Args);
      else
        alias State = staticMap!(ReduceSeedType!(ElementType!R), binfuns);

      foreach (i, f; binfuns)
      {
        static assert(!__traits(compiles, f(args[i], e)) || __traits(compiles,
            { args[i] = f(args[i], e); }()),
          algoFormat("Incompatible function/seed/element: %s/%s/%s",
            fullyQualifiedName!f, Args[i].stringof, E.stringof));
      }

      static struct Result
      {
      private:
        R source;
        State state;

        this(R range, ref Args args)
        {
          source = range;
          if (source.empty)
            return;

          foreach (i, f; binfuns)
          {
            static if (args.length)
              state[i] = f(args[i], source.front);
            else
              state[i] = source.front;
          }
        }

      public:
        @property bool empty()
        {
          return source.empty;
        }

        @property auto front()
        {
          assert(!empty, "Attempting to fetch the front of an empty cumulativeFold.");
          static if (fun.length > 1)
          {
            import std.typecons : tuple;
            return tuple(state);
          }
          else
          {
            return state[0];
          }
        }

        void popFront()
        {
          assert(!empty, "Attempting to popFront an empty cumulativeFold.");
          source.popFront;

          if (source.empty)
            return;

          foreach (i, f; binfuns)
            state[i] = f(state[i], source.front);
        }

        static if (isForwardRange!R)
        {
          @property auto save()
          {
            auto result = this;
            result.source = source.save;
            return result;
          }
        }

        static if (hasLength!R)
        {
          @property size_t length()
          {
            return source.length;
          }
        }
      }

      return Result(range, args);
    }
  }
}

// minElement/maxElement was added in D 2.072.0
static if (__VERSION__ < 2072) {
  private template RebindableOrUnqual(T)
  {
      static if (is(T == class) || is(T == interface) || isDynamicArray!T || isAssociativeArray!T)
          alias RebindableOrUnqual = Rebindable!T;
      else
          alias RebindableOrUnqual = Unqual!T;
  }
  private auto extremum(alias map, alias selector = "a < b", Range)(Range r)
  if (isInputRange!Range && !isInfinite!Range &&
      is(typeof(unaryFun!map(ElementType!(Range).init))))
  in
  {
      assert(!r.empty, "r is an empty range");
  }
  body
  {
      alias Element = ElementType!Range;
      RebindableOrUnqual!Element seed = r.front;
      r.popFront();
      return extremum!(map, selector)(r, seed);
  }

  private auto extremum(alias map, alias selector = "a < b", Range,
                        RangeElementType = ElementType!Range)
                       (Range r, RangeElementType seedElement)
  if (isInputRange!Range && !isInfinite!Range &&
      !is(CommonType!(ElementType!Range, RangeElementType) == void) &&
       is(typeof(unaryFun!map(ElementType!(Range).init))))
  {
      alias mapFun = unaryFun!map;
      alias selectorFun = binaryFun!selector;

      alias Element = ElementType!Range;
      alias CommonElement = CommonType!(Element, RangeElementType);
      RebindableOrUnqual!CommonElement extremeElement = seedElement;


      // if we only have one statement in the loop, it can be optimized a lot better
      static if (__traits(isSame, map, a => a))
      {

          // direct access via a random access range is faster
          static if (isRandomAccessRange!Range)
          {
              foreach (const i; 0 .. r.length)
              {
                  if (selectorFun(r[i], extremeElement))
                  {
                      extremeElement = r[i];
                  }
              }
          }
          else
          {
              while (!r.empty)
              {
                  if (selectorFun(r.front, extremeElement))
                  {
                      extremeElement = r.front;
                  }
                  r.popFront();
              }
          }
      }
      else
      {
          alias MapType = Unqual!(typeof(mapFun(CommonElement.init)));
          MapType extremeElementMapped = mapFun(extremeElement);

          // direct access via a random access range is faster
          static if (isRandomAccessRange!Range)
          {
              foreach (const i; 0 .. r.length)
              {
                  MapType mapElement = mapFun(r[i]);
                  if (selectorFun(mapElement, extremeElementMapped))
                  {
                      extremeElement = r[i];
                      extremeElementMapped = mapElement;
                  }
              }
          }
          else
          {
              while (!r.empty)
              {
                  MapType mapElement = mapFun(r.front);
                  if (selectorFun(mapElement, extremeElementMapped))
                  {
                      extremeElement = r.front;
                      extremeElementMapped = mapElement;
                  }
                  r.popFront();
              }
          }
      }
      return extremeElement;
  }

  private auto extremum(alias selector = "a < b", Range)(Range r)
  if (isInputRange!Range && !isInfinite!Range &&
      !is(typeof(unaryFun!selector(ElementType!(Range).init))))
  {
      return extremum!(a => a, selector)(r);
  }

  // if we only have one statement in the loop it can be optimized a lot better
  private auto extremum(alias selector = "a < b", Range,
                        RangeElementType = ElementType!Range)
                       (Range r, RangeElementType seedElement)
  if (isInputRange!Range && !isInfinite!Range &&
      !is(CommonType!(ElementType!Range, RangeElementType) == void) &&
      !is(typeof(unaryFun!selector(ElementType!(Range).init))))
  {
      return extremum!(a => a, selector)(r, seedElement);
  }

  auto minElement(alias map = (a => a), Range)(Range r)
  if (isInputRange!Range && !isInfinite!Range)
  {
      return extremum!map(r);
  }
  auto minElement(alias map = (a => a), Range, RangeElementType = ElementType!Range)
                 (Range r, RangeElementType seed)
  if (isInputRange!Range && !isInfinite!Range &&
      !is(CommonType!(ElementType!Range, RangeElementType) == void))
  {
      return extremum!map(r, seed);
  }
  auto maxElement(alias map = (a => a), Range)(Range r)
  if (isInputRange!Range && !isInfinite!Range)
  {
      return extremum!(map, "a > b")(r);
  }
  auto maxElement(alias map = (a => a), Range, RangeElementType = ElementType!Range)
                 (Range r, RangeElementType seed)
  if (isInputRange!Range && !isInfinite!Range &&
      !is(CommonType!(ElementType!Range, RangeElementType) == void))
  {
      return extremum!(map, "a > b")(r, seed);
  }
}

// popcnt with ulongs was added in D 2.071.0
static if (__VERSION__ < 2071) {
  ulong popcnt(ulong x) {
    x = (x & 0x5555555555555555L) + (x>> 1 & 0x5555555555555555L);
    x = (x & 0x3333333333333333L) + (x>> 2 & 0x3333333333333333L);
    x = (x & 0x0f0f0f0f0f0f0f0fL) + (x>> 4 & 0x0f0f0f0f0f0f0f0fL);
    x = (x & 0x00ff00ff00ff00ffL) + (x>> 8 & 0x00ff00ff00ff00ffL);
    x = (x & 0x0000ffff0000ffffL) + (x>>16 & 0x0000ffff0000ffffL);
    x = (x & 0x00000000ffffffffL) + (x>>32 & 0x00000000ffffffffL);
    return x;
  }
}


Measured memory_bytes: 21880