As usual, Sereja has array *a*, its elements are integers: *a*[1], *a*[2], ..., *a*[*n*]. Let's introduce notation:

A swap operation is the following sequence of actions:
 -  choose two indexes *i*, *j* (*i* ≠ *j*); -  perform assignments *tmp* = *a*[*i*], *a*[*i*] = *a*[*j*], *a*[*j*] = *tmp*. 
What maximum value of function *m*(*a*) can Sereja get if he is allowed to perform at most *k* swap operations?
The first line contains two integers *n* and *k* (1 ≤ *n* ≤ 200; 1 ≤ *k* ≤ 10). The next line contains *n* integers *a*[1], *a*[2], ..., *a*[*n*] ( - 1000 ≤ *a*[*i*] ≤ 1000).
from operator import itemgetter
from sys import stdin, stdout


def solve(a, k):
    aa = list(map(lambda x: [x[1], x[0]], enumerate(a)))
    aa.sort(reverse=True, key=itemgetter(0))
    if aa[0][0] < 0:
        return aa[0][0]

    best = -float("inf")
    for i in range(len(a)):
        for j in range(1, len(a)+1):
            in_range = sorted(a[i:j], reverse=True)
            out_of_range = sorted(a[:i] + a[j:])
            additional = []
            for kk in range(k):
                if len(out_of_range) > 0 and len(in_range) > 0 and in_range[-1] < out_of_range[-1]:
                    in_range.pop()
                    additional.append(out_of_range.pop())
            best = max(best, sum(in_range + additional))

    return best




if __name__ == "__main__":
    n, k = map(int, stdin.readline().split())
    a = [int(x) for x in stdin.readline().split()]
    stdout.write("{}\n".format(solve(a, k)))