using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace D
{
    class Program
    {
        static int n, maxK;
        static Dictionary<string, int> memo;

        static void Main(string[] args)
        {

            int[] nk = RArInt();
            n = nk[0];
            maxK = nk[1];
            int[] vs = RArInt();
            memo = new Dictionary<string, int>();

            int res = 0;
            int opeCnt = Math.Min(maxK, n);

            for (int lCnt = 0; lCnt <= opeCnt; lCnt++)
            {
                for (int rCnt = 0; rCnt <= opeCnt; rCnt++)
                {
                    if (lCnt + rCnt > opeCnt) continue;

                    var l = vs.Take(lCnt);
                    var r = vs.Skip(vs.Length - rCnt).Take(rCnt);

                    List<int> li = new List<int>();
                    foreach (var item in l) li.Add(item);
                    foreach (var item in r) li.Add(item);
                    li = li.OrderBy(x => x).ToList();

                    for (int i = 0; i < maxK - (lCnt + rCnt); i++)
                    {
                        if (i > li.Count - 1) break;
                        if (li[i] < 0) li[i] = 0;
                        else break;
                    }
                    res = Math.Max(res, li.Sum());
                }

            }
            Console.WriteLine(res < 0 ? 0 : res);

            //for (int i = 0; i <= opeCnt; i++)
            //{
            //    int lCnt = i;
            //    int rCnt = opeCnt - i;



            //    for (int j = 0; j <= l; j++)
            //    {
            //        lMax = Math.Max(lMax, vs.Take(j).Sum());
            //    }

            //    for (int j = 0; j <= r; j++)
            //    {
            //        rMax = Math.Max(rMax,.Sum());
            //    }
            //    res = Math.Max(res, lMax + rMax);



            //}
            //Console.WriteLine(res < 0 ? 0 : res);


            //LinkedList<int> q = new LinkedList<int>();
            //for (int i = 0; i < vs.Length; i++) q.AddLast(vs[i]);
            //int res = Dfs(new LinkedList<int>(q), new PriorityQueue<int>(), 0);
            //Console.WriteLine(res < 0 ? 0 : res);
        }

        //private static int Dfs(LinkedList<int> q, PriorityQueue<int> have, int k)
        //{
        //    int res = have.Buffer.Sum();
        //    string ky = C(q);
        //    if (memo.ContainsKey(ky)) return memo[ky];

        //    if (k < maxK)
        //    {
        //        //A
        //        if (q.Count > 0)
        //        {
        //            LinkedList<int> nq = new LinkedList<int>(q);
        //            PriorityQueue<int> nHave = new PriorityQueue<int>(have);
        //            nHave.Enqueue(nq.First.Value);
        //            nq.RemoveFirst();
        //            res = Math.Max(res, Dfs(nq, nHave, k + 1));
        //        }

        //        //B
        //        if (q.Count > 1)
        //        {
        //            LinkedList<int> nq = new LinkedList<int>(q);
        //            PriorityQueue<int> nHave = new PriorityQueue<int>(have);
        //            nHave.Enqueue(nq.Last.Value);
        //            nq.RemoveLast();
        //            res = Math.Max(res, Dfs(nq, nHave, k + 1));
        //        }

        //        if (have.Count > 0 && have.Peek() < 0)
        //        {
        //            //C
        //            LinkedList<int> nq = new LinkedList<int>(q);
        //            PriorityQueue<int> nHave = new PriorityQueue<int>(have);
        //            nq.AddFirst(nHave.Dequeue());
        //            res = Math.Max(res, Dfs(nq, nHave, k + 1));

        //            //D
        //            if (q.Count() > 0)
        //            {
        //                LinkedList<int> nq2 = new LinkedList<int>(q);
        //                PriorityQueue<int> nHave2 = new PriorityQueue<int>(have);
        //                nq2.AddFirst(nHave2.Dequeue());
        //                res = Math.Max(res, Dfs(nq2, nHave2, k + 1));
        //            }

        //        }

        //    }
        //    if (!memo.ContainsKey(ky)) memo.Add(ky, res);
        //    return res;
        //}

        //private static string C(LinkedList<int> q)
        //{
        //    string res = string.Empty;
        //    foreach (var item in q)
        //    {
        //        string s = item.ToString();
        //        res += item < 0 ? s : "+" + s;
        //    }
        //    return res;
        //}

        static string RSt() { return Console.ReadLine(); }
        static int RInt() { return int.Parse(Console.ReadLine().Trim()); }
        static long RLong() { return long.Parse(Console.ReadLine().Trim()); }
        static double RDouble() { return double.Parse(Console.ReadLine()); }
        static string[] RArSt(char sep = ' ') { return Console.ReadLine().Trim().Split(sep); }
        static int[] RArInt(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Trim().Split(sep), e => int.Parse(e)); }
        static long[] RArLong(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Trim().Split(sep), e => long.Parse(e)); }
        static double[] RArDouble(char sep = ' ') { return Array.ConvertAll(Console.ReadLine().Trim().Split(sep), e => double.Parse(e)); }
        static string WAr<T>(IEnumerable<T> array, string sep = " ") { return string.Join(sep, array.Select(x => x.ToString()).ToArray()); }
    }

    public class PriorityQueue<T> where T : IComparable<T>

    {

        public List<T> Buffer { get; set; }

        public int Count { get { return Buffer.Count; } }

        public PriorityQueue() { Buffer = new List<T>(); }
        public PriorityQueue(int capacity) { Buffer = new List<T>(capacity); }
        public PriorityQueue(PriorityQueue<T> pq) { Buffer = new List<T>(pq.Buffer); }

        /// <summary>
        /// ヒープ化されている配列リストに新しい要素を追加する。
        /// </summary>
        public void Enqueue(T item)
        {
            int n = Buffer.Count;
            Buffer.Add(item);

            while (n != 0)
            {
                int i = (n - 1) / 2;
                if (Buffer[n].CompareTo(Buffer[i]) * -1 > 0)
                {
                    T tmp = Buffer[n]; Buffer[n] = Buffer[i]; Buffer[i] = tmp;
                }
                n = i;
            }
        }

        /// <summary>
        /// ヒープから最大値を取り出し、削除する。
        /// </summary>
        public T Dequeue()
        {
            T ret = Buffer[0];
            int n = Buffer.Count - 1;
            Buffer[0] = Buffer[n];
            Buffer.RemoveAt(n);

            for (int i = 0, j; (j = 2 * i + 1) < n;)
            {
                if ((j != n - 1) && (Buffer[j].CompareTo(Buffer[j + 1]) * -1 < 0))
                    j++;
                if (Buffer[i].CompareTo(Buffer[j]) * -1 < 0)
                {
                    T tmp = Buffer[j]; Buffer[j] = Buffer[i]; Buffer[i] = tmp;
                }
                i = j;
            }
            return ret;
        }

        /// <summary>
        /// ヒープから最大値を参照する。
        /// </summary>
        public T Peek()
        {
            if (Count == 0) throw new InvalidOperationException();
            return this.Buffer[0];
        }
    }
}


Measured memory_bytes: 13408