#include <algorithm>
#include <cstdint>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>

typedef std::pair<size_t, size_t> range;

std::vector<range> split_work_by_limit(std::vector<uint64_t> const &solutions, uint64_t max_workload) {
    std::vector<range> ranges;

    size_t start = 0;
    uint64_t grader_workload = 0;

    for (size_t i = 0; i < solutions.size(); i++) {
        uint64_t workload = solutions[i];

        if (grader_workload + workload > max_workload) {
            ranges.push_back({start, i - 1});

            start = i;
            grader_workload = workload;
        } else {
            grader_workload += workload;
        }
    }

    ranges.push_back({start, solutions.size() - 1});

    return ranges;
}

std::vector<range> split_work_between_graders(std::vector<uint64_t> const &solutions, size_t max_graders) {
    uint64_t start = *std::max_element(solutions.begin(), solutions.end());
    uint64_t end = std::reduce(solutions.begin(), solutions.end());

    while (start < end) {
        uint64_t middle = (start + end) / 2;

        std::vector<range> ranges = split_work_by_limit(solutions, middle);

        if (ranges.size() > max_graders) {
            start = middle + 1;
        } else {
            end = middle;
        }
    }

    return split_work_by_limit(solutions, start);
}

int main() {
    std::cin.exceptions(std::cin.badbit | std::cin.failbit);
    std::cout.exceptions(std::cout.badbit | std::cout.failbit);

    size_t solution_count, max_graders;
    std::cin >> solution_count >> max_graders;

    std::vector<uint64_t> solutions;

    for (size_t i = 0; i < solution_count; i++) {
        uint64_t time;
        std::cin >> time;

        solutions.push_back(time);
    }

    std::vector<range> ranges = split_work_between_graders(solutions, max_graders);

    for (range r : ranges) {
        std::cout << (r.first + 1) << ' ' << (r.second + 1) << '\n';
    }
}