using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
using static System.Math;
using System.Linq;
using static System.Array;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var NK = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var N = NK[0];
            var K = NK[1];
            var V = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();

            //var cum = new long[N];
            //cum[0] = V[0];
            //for (int i = 1; i < N; i++)
            //{
            //    cum[i] = cum[i - 1] + V[i];
            //}

            var ans = long.MinValue;
            for (int i = 0; i <= Min(K,50) && i <= N; i++)
            {
                for (int l = 0; l <= i; l++)
                {
                    var sum = 0L;
                    var pq = new PriorityQueue<long>(false);
                    for (int j = 0; j < l; j++)
                    {
                        sum += V[j];
                        if(V[j] < 0)
                        {
                            pq.Enqueue(V[j]);
                        }
                    }

                    for (int j = 0; j < i-l; j++)
                    {
                        sum += V[N - j-1];
                        if(V[N - j-1] < 0)
                        {
                            pq.Enqueue(V[N - j-1]);
                        }
                    }

                    var del = K - i;
                    while (pq.Count() > 0 && del > 0)
                    {
                        sum -= pq.Dequeue();
                        del--;
                    }

                    if(ans < sum)
                    {
                        ans = sum;
                    }
                }
            }

            Console.WriteLine(ans);

            
        }

        public class PriorityQueue<T> : IEnumerable<T>
        {
            private readonly List<T> _data = new List<T>();
            private readonly IComparer<T> _comparer;
            private readonly bool _isDescending;

            public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
            {
                _comparer = comparer;
                _isDescending = isDescending;
            }

            public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
                : this(Comparer<T>.Create(comparison), isDescending)
            {
            }

            public PriorityQueue(bool isDescending = true)
                : this(Comparer<T>.Default, isDescending)
            {
            }

            public void Enqueue(T item)
            {
                _data.Add(item);
                var childIndex = _data.Count - 1;
                while (childIndex > 0)
                {
                    var parentIndex = (childIndex - 1) / 2;
                    if (Compare(_data[childIndex], _data[parentIndex]) >= 0)
                        break;
                    Swap(childIndex, parentIndex);
                    childIndex = parentIndex;
                }
            }

            public T Dequeue()
            {
                var lastIndex = _data.Count - 1;
                var firstItem = _data[0];
                _data[0] = _data[lastIndex];
                _data.RemoveAt(lastIndex--);
                var parentIndex = 0;
                while (true)
                {
                    var childIndex = parentIndex * 2 + 1;
                    if (childIndex > lastIndex)
                        break;
                    var rightChild = childIndex + 1;
                    if (rightChild <= lastIndex && Compare(_data[rightChild], _data[childIndex]) < 0)
                        childIndex = rightChild;
                    if (Compare(_data[parentIndex], _data[childIndex]) <= 0)
                        break;
                    Swap(parentIndex, childIndex);
                    parentIndex = childIndex;
                }
                return firstItem;
            }

            public T Peek()
            {
                return _data[0];
            }

            private void Swap(int a, int b)
            {
                var tmp = _data[a];
                _data[a] = _data[b];
                _data[b] = tmp;
            }

            private int Compare(T a, T b)
            {
                return _isDescending ? _comparer.Compare(b, a) : _comparer.Compare(a, b);
            }

            public int Count => _data.Count;

            public IEnumerator<T> GetEnumerator()
            {
                return _data.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        }


    }

}


Measured memory_bytes: 13524