program equeue
    implicit none
    integer(4),allocatable:: v(:)
    integer(4):: n,k
    integer(4):: i,j,li,ri,put, ans
    integer(4),allocatable:: get(:)

    read*, n, k
    allocate(v(n))
    read*, v(:)

    ans=-1000000000
    do li=0, min(n,k)
        do ri=0, min(n,k)-li
            put = min(n,k) - li - ri
            allocate(get(li+ri))
            get(:li) = v(:li)
            get(li+1:) = v(n-ri+1:)
            if (.not. li+ri == 0) call merge_sort(get,1,li+ri)
            do i=1, min(size(get),put)
                if (get(i) < 0) get(i) = 0 
            end do
            ! print*, li, ri, sum(get)
            ans=max(ans,sum(get))
            deallocate(get)
        end do
    end do

    print*, ans

contains
recursive subroutine merge_sort(ar,fst,lst)
    integer(4), intent(inout):: ar(:)
    integer(4), intent(in):: fst,lst
    integer(4):: mdl

    if (lst-fst < 2) then
        if (ar(fst) > ar(lst)) call swap(ar(fst), ar(lst))
        return
    end if

    mdl = (fst+lst)/2

    call merge_sort(ar,fst,mdl)
    call merge_sort(ar,mdl+1,lst)
    call merge_(ar,fst,mdl,lst)
end subroutine

subroutine merge_(ar,fst,mdl,lst)
    integer(4),intent(inout):: ar(:)
    integer(4),intent(in):: fst,mdl,lst
    integer(4),allocatable:: tmp(:)
    integer(4):: li, ri, ti
    
    allocate(tmp(lst-fst+1))
    li = fst
    ri = mdl+1
    ti = 1

    do while (li <= mdl .and. ri <= lst)
        if (ar(li) <= ar(ri)) then
            tmp(ti) = ar(li)
            li=li+1
        else
            tmp(ti) = ar(ri)
            ri=ri+1
        end if
        ti=ti+1
    end do
    

    if (li <= mdl) then
        tmp(ti:) = ar(li:mdl)
    else
        tmp(ti:) = ar(ri:lst)
    end if

    ar(fst:lst) = tmp(:)
    deallocate(tmp)
end subroutine

subroutine swap(x,y)
    integer(4), intent(inout):: x,y
    integer(4)::tmp
    tmp=x
    x=y
    y=tmp
end subroutine
    
end program equeue