#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <random>
#include <sstream>
#include <stdexcept>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>

namespace {

constexpr int kDefaultN = 20000;
constexpr int kDefaultMaxDepth = 3;
constexpr int kPreviewCount = 20;

std::string now() {
    timeval tv{};
    gettimeofday(&tv, nullptr);

    std::ostringstream oss;
    oss << tv.tv_sec << "." << std::setfill('0') << std::setw(6) << tv.tv_usec;
    return oss.str();
}

/* ========= ONLY MODIFIED PART ========= */
void log_start(int l, int r, int depth) {
    std::cout
        << "PROC_START"
        << " pid=" << getpid()
        << " ppid=" << getppid()
        << " depth=" << depth
        << " l=" << l
        << " r=" << r
        << " ts=" << now()
        << '\n'
        << std::flush;
}

void log_end(int l, int r, int depth) {
    std::cout
        << "PROC_END"
        << " pid=" << getpid()
        << " ppid=" << getppid()
        << " depth=" << depth
        << " l=" << l
        << " r=" << r
        << " ts=" << now()
        << '\n'
        << std::flush;
}
/* ====================================== */

void merge_range(int* arr, int l, int m, int r) {
    std::vector<int> temp;
    temp.reserve(r - l + 1);

    int i = l;
    int j = m + 1;

    while (i <= m && j <= r) {
        if (arr[i] <= arr[j]) {
            temp.push_back(arr[i++]);
        } else {
            temp.push_back(arr[j++]);
        }
    }

    while (i <= m) temp.push_back(arr[i++]);
    while (j <= r) temp.push_back(arr[j++]);

    std::copy(temp.begin(), temp.end(), arr + l);
}

void local_sort(int* arr, int l, int r) {
    if (l >= r) return;

    const int m = l + (r - l) / 2;
    local_sort(arr, l, m);
    local_sort(arr, m + 1, r);
    merge_range(arr, l, m, r);
}

void parallel_sort(int* arr, int l, int r, int depth, int max_depth) {
    log_start(l, r, depth);

    if (l >= r) {
        log_end(l, r, depth);
        return;
    }

    const int m = l + (r - l) / 2;
    if (depth >= max_depth) {
        local_sort(arr, l, r);
        log_end(l, r, depth);
        return;
    }

    pid_t left = fork();
    if (left == 0) {
        parallel_sort(arr, l, m, depth + 1, max_depth);
        _exit(EXIT_SUCCESS);
    }

    if (left < 0) {
        std::perror("fork left");
        local_sort(arr, l, m);
    }

    pid_t right = fork();
    if (right == 0) {
        parallel_sort(arr, m + 1, r, depth + 1, max_depth);
        _exit(EXIT_SUCCESS);
    }

    if (right < 0) {
        std::perror("fork right");
        local_sort(arr, m + 1, r);
    }

    int left_status = 0;
    if (left > 0 && waitpid(left, &left_status, 0) < 0) {
        std::perror("waitpid left");
        local_sort(arr, l, m);
    } else if (left > 0 && (!WIFEXITED(left_status) || WEXITSTATUS(left_status) != 0)) {
        local_sort(arr, l, m);
    }

    int right_status = 0;
    if (right > 0 && waitpid(right, &right_status, 0) < 0) {
        std::perror("waitpid right");
        local_sort(arr, m + 1, r);
    } else if (right > 0 && (!WIFEXITED(right_status) || WEXITSTATUS(right_status) != 0)) {
        local_sort(arr, m + 1, r);
    }

    merge_range(arr, l, m, r);
    log_end(l, r, depth);
}

bool parse_positive_int(const char* value, int& out) {
    try {
        size_t consumed = 0;
        const int parsed = std::stoi(value, &consumed);
        if (value[consumed] != '\0') return false;
        if (parsed <= 0) return false;
        out = parsed;
        return true;
    } catch (...) { return false; }
}

}  // namespace

int main(int argc, char* argv[]) {
    int n = kDefaultN;
    int max_depth = kDefaultMaxDepth;

    if (argc >= 2 && !parse_positive_int(argv[1], n)) {
        std::cerr << "Invalid array size: " << argv[1] << '\n';
        return EXIT_FAILURE;
    }
    if (argc >= 3 && !parse_positive_int(argv[2], max_depth)) {
        std::cerr << "Invalid max depth: " << argv[2] << '\n';
        return EXIT_FAILURE;
    }

    const size_t shm_size = static_cast<size_t>(n) * sizeof(int);
    const int shmid = shmget(IPC_PRIVATE, shm_size, IPC_CREAT | 0600);
    if (shmid < 0) {
        std::perror("shmget");
        return EXIT_FAILURE;
    }

    int* arr = static_cast<int*>(shmat(shmid, nullptr, 0));
    if (arr == reinterpret_cast<void*>(-1)) {
        std::perror("shmat");
        shmctl(shmid, IPC_RMID, nullptr);
        return EXIT_FAILURE;
    }

    std::mt19937 rng(std::random_device{}());
    std::uniform_int_distribution<int> dist(0, 99999);
    for (int i = 0; i < n; ++i) arr[i] = dist(rng);

    parallel_sort(arr, 0, n - 1, 0, max_depth);

    if (shmdt(arr) < 0) std::perror("shmdt");
    if (shmctl(shmid, IPC_RMID, nullptr) < 0) std::perror("shmctl IPC_RMID");

    return EXIT_SUCCESS;
}