using System.Collections;
using System.Text;
using System.Threading.Tasks;
using static System.Math;
using static System.Console;
using System.Collections.Generic;
using System.Linq;
using System;
using System.Numerics;
using System.IO.Pipes;
using System.Threading;
using System.Net;
using System.Runtime.Serialization;
using System.Globalization;
using System.Collections.Immutable;
using System.Data.SqlTypes;
using System.Security.Cryptography;

class Program
{
    #region Reader

    static string ReadStr => Console.ReadLine();
    static string[] ReadStrs => Console.ReadLine().Split(' ');
    static int ReadInt => Convert.ToInt32(Console.ReadLine());
    static int[] ReadInts => Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray();
    static long ReadLong => Convert.ToInt64(Console.ReadLine());
    static long[] ReadLongs => Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray();
    static long[,] ReLongMatrix(int r, int c)
    {
        var mat = new long[r, c];
        for (int i = 0; i < r; ++i)
        {
            var x = ReadLongs;
            for (int j = 0; j < c; ++j)
            {
                mat[i, j] = x[j];
            }
        }
        return mat;
    }
    static Tuple<string, string>[] ReTupleStr(int n)
    {
        List<Tuple<string, string>> list = new List<Tuple<string, string>>();
        for (int i = 0; i < n; ++i)
        {
            var ab = ReadStrs;
            list.Add(new Tuple<string, string>(ab[0], ab[1]));
        }
        return list.ToArray();
    }
    static Tuple<long, long>[] ReTupleLong(int n)
    {
        List<Tuple<long, long>> list = new List<Tuple<long, long>>();
        for (int i = 0; i < n; ++i)
        {
            var ab = ReadLongs;
            list.Add(new Tuple<long, long>(ab[0], ab[1]));
        }
        return list.ToArray();
    }
    static Tuple<int, int>[] ReadTupleInt(int n)
    {
        List<Tuple<int, int>> list = new List<Tuple<int, int>>();
        for (int i = 0; i < n; ++i)
        {
            var ab = ReadInts;
            list.Add(new Tuple<int, int>(ab[0], ab[1]));
        }
        return list.ToArray();
    }
    static Tuple<double, double>[] ReTupleDouble(int n)
    {
        List<Tuple<double, double>> list = new List<Tuple<double, double>>();
        for (int i = 0; i < n; ++i)
        {
            var ab = ReadLongs;
            list.Add(new Tuple<double, double>(ab[0], ab[1]));
        }
        return list.ToArray();
    }
    static Dictionary<int, HashSet<int>> ReAdjacencyList(int N, int M)
    {
        Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
        for (int i = 0; i <= N; ++i)
        {
            dict.Add(i, new HashSet<int>());
        }
        for (int i = 0; i < M; ++i)
        {
            var ab = ReadInts;
            dict[ab[0]].Add(ab[1]);
            dict[ab[1]].Add(ab[0]);
        }
        return dict;
    }
    #endregion
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
    static int mod = (int)Pow(10, 9) + 7;

 
    static void Main()
    {
        int[] NK = ReadInts;
        int N = NK[0];
        int K= NK[1];

        int[] juels = ReadInts;

        
        long sum = 0;
        long sum_left = 0;
        List<int> hand_l = new List<int>();

        long ans = 0;

        for (int i = 0; i <= K; i++)
        {
            if (i > N)
            {
                break;
            }

            if (i - 1 >= 0)
            {
                sum_left += juels[i-1];
                hand_l.Add(juels[i - 1]);
            }
            sum = sum_left;

            SortedSet<int> hand = new SortedSet<int>();
            foreach (var item in hand_l)
            {
                hand.Add(item);
            }

            for (int j = 0; j <= K-i; j++)
            {
               
                if (i + j > N)
                {
                    break;
                }
                if (j != 0)
                {
                    sum += juels[N - j];
                    hand.Add(juels[N - j]);
                }
        


                long d = 0;
                for (int k = 0; k <= K-i-j; k++)
                {
                    if (k - 1 >= hand.Count()) break;
                    if(k!=0)d += hand.ElementAt(k-1);
                    ans = Max(ans, sum - d);
                }
            }
        }


        WriteLine(ans);
    }

    

}


Measured memory_bytes: 36780