There are N panels arranged in a row in Takahashi's house, numbered 1 through N. The i-th panel has a number A_i written on it. Takahashi is playing by throwing balls at these panels.

Takahashi threw a ball K times. Let the panel hit by a boll in the i-th throw be panel p_i. He set the score for the i-th throw as i \times A_{p_i}.

He was about to calculate the total score for his throws, when he realized that he forgot the panels hit by balls, p_1,p_2,...,p_K. The only fact he remembers is that for every i (1 ≦ i ≦ K-1), 1 ≦ p_{i+1}-p_i ≦ M holds. Based on this fact, find the maximum possible total score for his throws.

Constraints

* 1 ≦ M ≦ N ≦ 100,000
* 1 ≦ K ≦ min(300,N)
* 1 ≦ A_i ≦ 10^{9}

Input

The input is given from Standard Input in the following format:


N M K
A_1 A_2 … A_N


Output

Print the maximum possible total score for Takahashi's throws.

Examples

Input

5 2 3
10 2 8 10 2


Output

56


Input

5 5 2
5 2 10 5 9


Output

28


Input

10 3 5
3 7 2 6 9 4 8 5 1 1000000000


Output

5000000078
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;

#ifdef LOCAL
	#define eprintf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
	#define eprintf(...) 42
#endif

using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template<typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
	return (ull)rng() % B;
}

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second

clock_t startTime;
double getCurrentTime() {
	return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}

const ll INF = (ll)1e18;

struct Stack {
	vector<ll> vals, maxs;

	Stack() : vals(), maxs({-INF}) {}

	void push(ll x) {
		vals.push_back(x);
		maxs.push_back(max(x, maxs.back()));
	}
	ll pop() {
		maxs.pop_back();
		ll x = vals.back();
		vals.pop_back();
		return x;
	}
	ll getMax() const {
		return maxs.back();
	}
	bool empty() const {
		return vals.empty();
	}
};
struct Queue {
	Stack A, B;

	Queue() : A(), B() {}

	void push(ll x) {
		A.push(x);
	}
	ll pop() {
		if (B.empty()) {
			while(!A.empty()) {
				B.push(A.pop());
			}
		}
		assert(!B.empty());
		return B.pop();
	}
	ll getMax() {
		return max(A.getMax(), B.getMax());
	}
};

const int N = 100100;
int n, m, k;
ll a[N];
ll dp[N];

int main()
{
	startTime = clock();
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);

	scanf("%d%d%d", &n, &m, &k);
	for (int i = 0; i < n; i++) {
		scanf("%lld", &a[i]);
		dp[i] = a[i];
	}
	for (int it = 2; it <= k; it++) {
		Queue Q = Queue();
		for (int i = 0; i < n; i++) {
			ll x = dp[i];
			if (i - m - 1 >= 0) Q.pop();
			dp[i] = Q.getMax() + it * a[i];
			Q.push(x);
		}
	}
	ll ans = -INF;
	for (int i = 0; i < n; i++)
		ans = max(ans, dp[i]);
	printf("%lld\n", ans);

	return 0;
}
