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

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

            //var lcum = new int[N];
            //var rcum = new int[N];

            ////累積和を計算
            //lcum[0] = V[0];
            //rcum[0] = V[N - 1];
            
            //for(int i = 1; i < N; i++)
            //{
            //    lcum[i] = lcum[i - 1] + V[i]; 
            //}

            //for (int i = 1; i < N; i++)
            //{
            //    rcum[i] = rcum[i - 1] + V[N-1-i];
            //}

            var ans = 0;

            //何個宝石を取り出すか
            for (int remove = 0; remove <= K && remove <= N; remove++)
            {
                
                for (int l = 0; l <= remove; l++)
                {
                    var sum = 0;
                    var q = new PriorityQueue<int>(isDescending: false);
                    //取り出す右の個数
                    var r = remove - l;
                    //左からl個取り出す
                    for(int i = 0; i < l; i++)
                    {
                        sum += V[i];
                        if(V[i] < 0)
                        {
                            q.Enqueue(V[i]);
                        }
                    }
                    //右からr個取り出す
                    for (int i = 0; i < r; i++)
                    {
                        sum += V[N-1-i];
                        if (V[N - 1 - i] < 0)
                        {
                            q.Enqueue(V[N - 1 - i]);
                        }
                    }

                    //K-remove個までマイナスの値を取り除く
                    for (int i = 0; i < K - remove; i++)
                    {
                        if(q.Count > 0)
                        {
                            sum -= q.Dequeue();
                        }
                    }
                    //最大値となるかを調査
                    ans = Math.Max(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: 13396