Kevin Sun wants to move his precious collection of n cowbells from Naperthrill to Exeter, where there is actually grass instead of corn. Before moving, he must pack his cowbells into k boxes of a fixed size. In order to keep his collection safe during transportation, he won't place more than two cowbells into a single box. Since Kevin wishes to minimize expenses, he is curious about the smallest size box he can use to pack his entire collection. 

Kevin is a meticulous cowbell collector and knows that the size of his i-th (1 ≤ i ≤ n) cowbell is an integer si. In fact, he keeps his cowbells sorted by size, so si - 1 ≤ si for any i > 1. Also an expert packer, Kevin can fit one or two cowbells into a box of size s if and only if the sum of their sizes does not exceed s. Given this information, help Kevin determine the smallest s for which it is possible to put all of his cowbells into k boxes of size s.

Input

The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 2·k ≤ 100 000), denoting the number of cowbells and the number of boxes, respectively.

The next line contains n space-separated integers s1, s2, ..., sn (1 ≤ s1 ≤ s2 ≤ ... ≤ sn ≤ 1 000 000), the sizes of Kevin's cowbells. It is guaranteed that the sizes si are given in non-decreasing order.

Output

Print a single integer, the smallest s for which it is possible for Kevin to put all of his cowbells into k boxes of size s.

Examples

Input

2 1
2 5


Output

7


Input

4 3
2 3 5 9


Output

9


Input

3 2
3 5 7


Output

8

Note

In the first sample, Kevin must pack his two cowbells into the same box. 

In the second sample, Kevin can pack together the following sets of cowbells: {2, 3}, {5} and {9}.

In the third sample, the optimal solution is {3, 5} and {7}.
import java.util.*;
import java.io.*;

/**
  * @author Mighty Cohadar 
  */
public class Bravo {

	final int n;
	final int k;
	final int[] S;
	
	public Bravo(int n, int k, int[] S) {
		this.n = n;
		this.k = k;
		this.S = S;
	}

	public boolean canFit(int s) {
		if (s < S[n - 1]) {
			return false;
		}
		if (k >= n) {
			return true;
		}
		int fits = n - k;
		for (int i = 0; i < fits; i++) {
			int j = 2 * fits - i - 1;
			if (S[i] + S[j] > s) {
				return false;
			}
		}
		return true;
	}

	public int lowerBound(int l, int r) {
		while (l <= r) {
			int m = (l + r) >>> 1;
			if (canFit(m)) {
				r = m - 1;
			} else {
				l = m + 1;
			}
		}
		return l;
	}

	public int solve() {
		return lowerBound(S[n - 1], 2 * S[n - 1]);
	}

	public static Bravo load(Scanner scanner) {
		int n = scanner.nextInt();
		int k = scanner.nextInt();
		assert 1 <= n && n <= 1e5 : "out of range, n: " + n;
		assert n <= 2 * k && 2 * k <= 1e5 : "out of range, 2 * k: " + 2 * k;
		int[] S = scanArray(scanner, n); // input is sorted
		return new Bravo(n, k, S);
	} 

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		Bravo o = Bravo.load(scanner);
		System.out.println(o.solve());
	}

	static int[] scanArray(Scanner scanner, int n) {
		int[] A = new int[n];
		for (int i = 0; i < n; i++) {
			A[i] = scanner.nextInt();
		}
		return A;
	}

}
