#include <iostream>
#include <vector>
#include <queue>
#include <set>

template<class T>
class Solver {
private:
    
    struct Segment {
        T segmentSum;
        size_t L, R;
        
        Segment (const size_t& L = 0, const size_t& R = 0, const T& segmentSum = 0) {
            this->L = L;
            this->R = R;
            this->segmentSum = segmentSum;
        }
        
        bool operator < (const Segment& opponent) const {
            return (segmentSum < opponent.segmentSum);
        }
        
    };
    
    size_t N;
    size_t K;
    std::vector<T> A;
    std::vector<T> answer;
    std::priority_queue<Segment> availableSegments;
    std::set<std::pair<size_t, size_t> > addedSegments;
    
    void addIfNotAddedAlready (const Segment& currentSegment) {
        std::pair<size_t, size_t> segmentBounds = std::make_pair(currentSegment.L, currentSegment.R);
        if (addedSegments.find(segmentBounds) == addedSegments.end()) {
            addedSegments.insert(segmentBounds);
            availableSegments.push(currentSegment);
        }
    }
    
public:
    
    void inputData (std::istream& inputStream) {
        inputStream >> N >> K;
        A.resize(N);
        for(size_t i = 0; i < N; ++i) {
            inputStream >> A[i];
        }
    }
    
    void solve () {
        T sumOfAllNumbers = 0;
        for(T currentNumber : A) {
            sumOfAllNumbers += currentNumber;
        }
        availableSegments.push(Segment(0, N - 1, sumOfAllNumbers));
        for(size_t i = 0; i < K; ++i) {
            Segment currentMaximalSegment = availableSegments.top();
            availableSegments.pop();
            answer.push_back(currentMaximalSegment.segmentSum);
            if (currentMaximalSegment.L < currentMaximalSegment.R) {
                Segment newSegmentWithoutLeft = Segment(currentMaximalSegment.L + 1, currentMaximalSegment.R, currentMaximalSegment.segmentSum - A[currentMaximalSegment.L]);
                Segment newSegmentWithoutRight = Segment(currentMaximalSegment.L, currentMaximalSegment.R - 1, currentMaximalSegment.segmentSum - A[currentMaximalSegment.R]);
                addIfNotAddedAlready(newSegmentWithoutLeft);
                addIfNotAddedAlready(newSegmentWithoutRight);
            }
        }
    }
    
    void outputData (std::ostream& outputStream) {
        for(size_t i = 0; i + 1 < answer.size(); ++i) {
            outputStream << answer[i] << " ";
        }
        outputStream << answer.back() << std::endl;
    }
    
};


int main(int argc, const char * argv[]) {
    Solver<long long> mySolver;
    mySolver.inputData(std::cin);
    mySolver.solve();
    mySolver.outputData(std::cout);
    return 0;
}