From 0b31a50c20c1054edf3377d2c920481e48e7cd6c Mon Sep 17 00:00:00 2001
From: pajjilykk <pgoldendragon@gmail.com>
Date: Wed, 13 May 2026 08:54:08 +0700
Subject: [PATCH] add 13 comp

---
 13comp/Makefile      |  25 +++
 13comp/exporter.py   | 168 +++++++++++++++++++
 13comp/pipe_sort     | Bin 0 -> 38712 bytes
 13comp/pipe_sort.cpp | 377 +++++++++++++++++++++++++++++++++++++++++++
 13comp/shm_sort      | Bin 0 -> 33560 bytes
 13comp/shm_sort.cpp  | 295 +++++++++++++++++++++++++++++++++
 6 files changed, 865 insertions(+)
 create mode 100644 13comp/Makefile
 create mode 100644 13comp/exporter.py
 create mode 100755 13comp/pipe_sort
 create mode 100644 13comp/pipe_sort.cpp
 create mode 100755 13comp/shm_sort
 create mode 100644 13comp/shm_sort.cpp

diff --git a/13comp/Makefile b/13comp/Makefile
new file mode 100644
index 0000000..1ec5d82
--- /dev/null
+++ b/13comp/Makefile
@@ -0,0 +1,25 @@
+CXX := g++
+CXXFLAGS := -O2 -std=c++17 -Wall -Wextra -pedantic
+PYTHON := $(abspath ../.venv/bin/python)
+OUT_DIR := out
+
+.PHONY: all run test export clean
+
+all: shm_sort pipe_sort
+
+shm_sort: shm_sort.cpp
+	$(CXX) $(CXXFLAGS) shm_sort.cpp -o shm_sort
+
+pipe_sort: pipe_sort.cpp
+	$(CXX) $(CXXFLAGS) pipe_sort.cpp -o pipe_sort
+
+run: all
+	$(PYTHON) exporter.py --out $(OUT_DIR)
+
+test: run
+
+export: run
+
+clean:
+	rm -f shm_sort pipe_sort
+	rm -rf $(OUT_DIR) __pycache__
diff --git a/13comp/exporter.py b/13comp/exporter.py
new file mode 100644
index 0000000..ee3d8b8
--- /dev/null
+++ b/13comp/exporter.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import re
+import subprocess
+from pathlib import Path
+
+os.environ.setdefault("MPLCONFIGDIR", str(Path("out") / ".matplotlib"))
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+STAT_RE = re.compile(
+    r"STAT: program=(\w+) size=(\d+) depth=(\d+) min_size=(\d+) valid=(\d+) time=([\d.eE+-]+)"
+)
+
+
+def seed_for(size: int, repeat: int) -> int:
+    return 13013 + size * 17 + repeat * 1_000_003
+
+
+def run_once(binary: str, program: str, size: int, depth: int, min_size: int, seed: int) -> dict:
+    cmd = [
+        binary,
+        "--size",
+        str(size),
+        "--depth",
+        str(depth),
+        "--min-size",
+        str(min_size),
+        "--seed",
+        str(seed),
+    ]
+
+    proc = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
+
+    if proc.returncode != 0:
+        raise RuntimeError("Command failed: " + " ".join(cmd) + "\n" + proc.stderr)
+
+    match = STAT_RE.search(proc.stderr)
+    if not match:
+        raise RuntimeError("STAT line not found: " + proc.stderr)
+
+    stat_program, stat_size, stat_depth, stat_min_size, valid, elapsed = match.groups()
+
+    if stat_program != program:
+        raise RuntimeError(f"expected program={program}, got {stat_program}")
+    if valid != "1":
+        raise RuntimeError("sort validation failed: " + proc.stderr)
+
+    return {
+        "program": program,
+        "size": int(stat_size),
+        "depth": int(stat_depth),
+        "min_size": int(stat_min_size),
+        "seed": seed,
+        "time": float(elapsed),
+    }
+
+
+def write_csv(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    header = ["program", "size", "depth", "min_size", "seed", "time"]
+
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=header)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def draw_graph(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    sizes = sorted({row["size"] for row in rows})
+    programs = ["shm", "pipe"]
+    markers = {"shm": "o", "pipe": "s"}
+    labels = {"shm": "Разделяемая память", "pipe": "Каналы"}
+
+    fig, (time_ax, speed_ax) = plt.subplots(1, 2, figsize=(15, 6))
+
+    for program in programs:
+        cur = [row for row in rows if row["program"] == program]
+        cur.sort(key=lambda row: row["size"])
+        time_ax.plot(
+            [row["size"] for row in cur],
+            [row["time"] for row in cur],
+            marker=markers[program],
+            label=labels[program],
+        )
+
+    for program in programs:
+        cur = [row for row in rows if row["program"] == program]
+        cur.sort(key=lambda row: row["size"])
+        speed_ax.plot(
+            [row["size"] for row in cur],
+            [row["size"] / row["time"] if row["time"] > 0 else 0 for row in cur],
+            marker=markers[program],
+            label=labels[program],
+        )
+
+    time_ax.set_xscale("log", base=2)
+    speed_ax.set_xscale("log", base=2)
+
+    time_ax.set_xlabel("Размер списка")
+    time_ax.set_ylabel("Время, секунды")
+    time_ax.set_title("Время сортировки связного списка слиянием")
+    time_ax.grid(True)
+    time_ax.legend()
+
+    speed_ax.set_xlabel("Размер списка")
+    speed_ax.set_ylabel("Элементов в секунду")
+    speed_ax.set_title("Скорость сортировки на одинаковых нагрузках")
+    speed_ax.grid(True)
+    speed_ax.legend()
+
+    fig.suptitle("Разделяемая память и каналы: задача сортировки списка из лабораторной 1")
+    fig.tight_layout()
+    fig.savefig(path, dpi=150)
+    plt.close(fig)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out", default="out", help="output directory")
+    parser.add_argument("--depth", type=int, default=3)
+    parser.add_argument("--min-size", type=int, default=4096)
+    parser.add_argument("--repeats", type=int, default=3)
+    parser.add_argument(
+        "--sizes",
+        type=int,
+        nargs="+",
+        default=[2**power for power in range(9, 19)],
+    )
+    args = parser.parse_args()
+
+    out_dir = Path(args.out)
+    rows = []
+
+    for size in args.sizes:
+        for program, binary in [("shm", "./shm_sort"), ("pipe", "./pipe_sort")]:
+            measurements = []
+
+            for repeat in range(args.repeats):
+                seed = seed_for(size, repeat)
+                row = run_once(binary, program, size, args.depth, args.min_size, seed)
+                measurements.append(row)
+                print(
+                    f"{program}: size={size} repeat={repeat + 1}/{args.repeats} "
+                    f"time={row['time']:.6f}",
+                    flush=True,
+                )
+
+            best = min(measurements, key=lambda row: row["time"])
+            rows.append(best)
+
+    write_csv(out_dir / "benchmark.csv", rows)
+    draw_graph(out_dir / "speed_comparison.png", rows)
+    print(f"Saved {out_dir / 'benchmark.csv'}")
+    print(f"Saved {out_dir / 'speed_comparison.png'}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/13comp/pipe_sort b/13comp/pipe_sort
new file mode 100755
index 0000000000000000000000000000000000000000..3c0282b6ee8d828623f8977b93baddb092e6031f
GIT binary patch
literal 38712
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

literal 0
HcmV?d00001

diff --git a/13comp/pipe_sort.cpp b/13comp/pipe_sort.cpp
new file mode 100644
index 0000000..0c11509
--- /dev/null
+++ b/13comp/pipe_sort.cpp
@@ -0,0 +1,377 @@
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+
+constexpr int NIL = -1;
+
+struct Node {
+    int32_t value;
+    int next;
+};
+
+struct Options {
+    size_t size = 100000;
+    int max_depth = 3;
+    size_t min_size = 4096;
+    unsigned seed = 1337;
+    bool print = false;
+};
+
+struct SortResult {
+    std::vector<int32_t> values;
+};
+
+static void throw_errno(const std::string& what) {
+    throw std::runtime_error(what + ": " + std::strerror(errno));
+}
+
+static void close_checked(int fd) {
+    if (fd >= 0) {
+        while (close(fd) < 0 && errno == EINTR) {}
+    }
+}
+
+static void write_all(int fd, const void* data, size_t bytes) {
+    const char* p = static_cast<const char*>(data);
+
+    while (bytes > 0) {
+        ssize_t n = write(fd, p, bytes);
+        if (n < 0) {
+            if (errno == EINTR) continue;
+            throw_errno("write");
+        }
+        if (n == 0) throw std::runtime_error("write returned zero");
+        p += n;
+        bytes -= static_cast<size_t>(n);
+    }
+}
+
+static void read_all(int fd, void* data, size_t bytes) {
+    char* p = static_cast<char*>(data);
+
+    while (bytes > 0) {
+        ssize_t n = read(fd, p, bytes);
+        if (n < 0) {
+            if (errno == EINTR) continue;
+            throw_errno("read");
+        }
+        if (n == 0) throw std::runtime_error("unexpected EOF");
+        p += n;
+        bytes -= static_cast<size_t>(n);
+    }
+}
+
+static void send_values(int fd, const std::vector<int32_t>& values) {
+    uint64_t n = static_cast<uint64_t>(values.size());
+    write_all(fd, &n, sizeof(n));
+    if (!values.empty()) write_all(fd, values.data(), values.size() * sizeof(values[0]));
+}
+
+static std::vector<int32_t> recv_values(int fd) {
+    uint64_t n = 0;
+    read_all(fd, &n, sizeof(n));
+
+    if (n > static_cast<uint64_t>(SIZE_MAX / sizeof(int32_t))) {
+        throw std::runtime_error("input too large");
+    }
+
+    std::vector<int32_t> values(static_cast<size_t>(n));
+    if (!values.empty()) read_all(fd, values.data(), values.size() * sizeof(values[0]));
+    return values;
+}
+
+static int merge_lists(std::vector<Node>& nodes, int left, int right) {
+    if (left == NIL) return right;
+    if (right == NIL) return left;
+
+    int head = NIL;
+    int tail = NIL;
+
+    auto append = [&](int idx) {
+        if (head == NIL) {
+            head = idx;
+            tail = idx;
+        } else {
+            nodes[tail].next = idx;
+            tail = idx;
+        }
+    };
+
+    while (left != NIL && right != NIL) {
+        if (nodes[left].value <= nodes[right].value) {
+            int next = nodes[left].next;
+            append(left);
+            left = next;
+        } else {
+            int next = nodes[right].next;
+            append(right);
+            right = next;
+        }
+    }
+
+    if (left != NIL) nodes[tail].next = left;
+    if (right != NIL) nodes[tail].next = right;
+    return head;
+}
+
+static void split_list(std::vector<Node>& nodes, int head, int& left, int& right) {
+    if (head == NIL || nodes[head].next == NIL) {
+        left = head;
+        right = NIL;
+        return;
+    }
+
+    int slow = head;
+    int fast = nodes[head].next;
+
+    while (fast != NIL) {
+        fast = nodes[fast].next;
+        if (fast != NIL) {
+            slow = nodes[slow].next;
+            fast = nodes[fast].next;
+        }
+    }
+
+    left = head;
+    right = nodes[slow].next;
+    nodes[slow].next = NIL;
+}
+
+static int local_sort(std::vector<Node>& nodes, int head) {
+    if (head == NIL || nodes[head].next == NIL) return head;
+
+    int left = NIL;
+    int right = NIL;
+    split_list(nodes, head, left, right);
+    left = local_sort(nodes, left);
+    right = local_sort(nodes, right);
+    return merge_lists(nodes, left, right);
+}
+
+static std::vector<Node> make_nodes(const std::vector<int32_t>& values) {
+    std::vector<Node> nodes(values.size());
+
+    for (size_t i = 0; i < values.size(); ++i) {
+        nodes[i].value = values[i];
+        nodes[i].next = (i + 1 == values.size()) ? NIL : static_cast<int>(i + 1);
+    }
+
+    return nodes;
+}
+
+static std::vector<int32_t> collect_values(const std::vector<Node>& nodes, int head) {
+    std::vector<int32_t> out;
+    out.reserve(nodes.size());
+
+    for (int cur = head; cur != NIL; cur = nodes[cur].next) {
+        out.push_back(nodes[cur].value);
+    }
+
+    return out;
+}
+
+static std::vector<int32_t> sort_values_as_list(std::vector<int32_t> values) {
+    if (values.size() < 2) return values;
+
+    std::vector<Node> nodes = make_nodes(values);
+    int head = local_sort(nodes, 0);
+    return collect_values(nodes, head);
+}
+
+static void split_values_as_list(const std::vector<int32_t>& values,
+                                 std::vector<int32_t>& left_values,
+                                 std::vector<int32_t>& right_values) {
+    std::vector<Node> nodes = make_nodes(values);
+
+    int left = NIL;
+    int right = NIL;
+    split_list(nodes, values.empty() ? NIL : 0, left, right);
+
+    left_values = collect_values(nodes, left);
+    right_values = collect_values(nodes, right);
+}
+
+static std::vector<int32_t> merge_values_as_list(const std::vector<int32_t>& left_values,
+                                                 const std::vector<int32_t>& right_values) {
+    std::vector<Node> nodes;
+    nodes.reserve(left_values.size() + right_values.size());
+
+    int left = NIL;
+    int left_tail = NIL;
+    for (int32_t value : left_values) {
+        int idx = static_cast<int>(nodes.size());
+        nodes.push_back({value, NIL});
+        if (left == NIL) left = idx;
+        else nodes[left_tail].next = idx;
+        left_tail = idx;
+    }
+
+    int right = NIL;
+    int right_tail = NIL;
+    for (int32_t value : right_values) {
+        int idx = static_cast<int>(nodes.size());
+        nodes.push_back({value, NIL});
+        if (right == NIL) right = idx;
+        else nodes[right_tail].next = idx;
+        right_tail = idx;
+    }
+
+    int head = merge_lists(nodes, left, right);
+    return collect_values(nodes, head);
+}
+
+static SortResult parallel_sort(std::vector<int32_t> values, int depth, const Options& opt);
+
+static pid_t spawn_child(const std::vector<int32_t>& part,
+                         int depth,
+                         const Options& opt,
+                         int& result_fd) {
+    int to_child[2] = {-1, -1};
+    int from_child[2] = {-1, -1};
+
+    if (pipe(to_child) < 0) throw_errno("pipe to_child");
+    if (pipe(from_child) < 0) throw_errno("pipe from_child");
+
+    pid_t pid = fork();
+    if (pid < 0) throw_errno("fork");
+
+    if (pid == 0) {
+        try {
+            close_checked(to_child[1]);
+            close_checked(from_child[0]);
+
+            std::vector<int32_t> input = recv_values(to_child[0]);
+            close_checked(to_child[0]);
+
+            SortResult result = parallel_sort(std::move(input), depth, opt);
+            send_values(from_child[1], result.values);
+            close_checked(from_child[1]);
+            _exit(0);
+        } catch (...) {
+            _exit(2);
+        }
+    }
+
+    close_checked(to_child[0]);
+    close_checked(from_child[1]);
+    send_values(to_child[1], part);
+    close_checked(to_child[1]);
+
+    result_fd = from_child[0];
+    return pid;
+}
+
+static SortResult parallel_sort(std::vector<int32_t> values, int depth, const Options& opt) {
+    if (values.size() < 2 || depth >= opt.max_depth || values.size() <= opt.min_size) {
+        return {sort_values_as_list(std::move(values))};
+    }
+
+    std::vector<int32_t> left;
+    std::vector<int32_t> right;
+    split_values_as_list(values, left, right);
+
+    int left_fd = -1;
+    int right_fd = -1;
+    pid_t left_pid = spawn_child(left, depth + 1, opt, left_fd);
+    pid_t right_pid = spawn_child(right, depth + 1, opt, right_fd);
+
+    std::vector<int32_t> sorted_left = recv_values(left_fd);
+    std::vector<int32_t> sorted_right = recv_values(right_fd);
+    close_checked(left_fd);
+    close_checked(right_fd);
+
+    int left_status = 0;
+    int right_status = 0;
+    while (waitpid(left_pid, &left_status, 0) < 0 && errno == EINTR) {}
+    while (waitpid(right_pid, &right_status, 0) < 0 && errno == EINTR) {}
+
+    if (!WIFEXITED(left_status) || WEXITSTATUS(left_status) != 0) {
+        throw std::runtime_error("left child failed");
+    }
+    if (!WIFEXITED(right_status) || WEXITSTATUS(right_status) != 0) {
+        throw std::runtime_error("right child failed");
+    }
+
+    return {merge_values_as_list(sorted_left, sorted_right)};
+}
+
+static Options parse_args(int argc, char** argv) {
+    Options opt;
+
+    for (int i = 1; i < argc; ++i) {
+        std::string s = argv[i];
+
+        auto value = [&](const std::string& name) -> std::string {
+            if (i + 1 >= argc) throw std::runtime_error("missing value for " + name);
+            return argv[++i];
+        };
+
+        if (s == "--size" || s == "-n") {
+            opt.size = std::stoull(value(s));
+        } else if (s == "--depth" || s == "-d") {
+            opt.max_depth = std::stoi(value(s));
+        } else if (s == "--min-size" || s == "-m") {
+            opt.min_size = std::stoull(value(s));
+        } else if (s == "--seed") {
+            opt.seed = static_cast<unsigned>(std::stoul(value(s)));
+        } else if (s == "--print") {
+            opt.print = true;
+        } else if (s == "--help" || s == "-h") {
+            std::cout << "Usage: ./pipe_sort [--size N] [--depth D] [--min-size M] "
+                      << "[--seed S] [--print]\n";
+            std::exit(0);
+        } else {
+            throw std::runtime_error("unknown argument: " + s);
+        }
+    }
+
+    if (opt.max_depth < 0) throw std::runtime_error("depth must be non-negative");
+    if (opt.size == 0) throw std::runtime_error("size must be positive");
+    return opt;
+}
+
+int main(int argc, char** argv) {
+    try {
+        Options opt = parse_args(argc, argv);
+        std::vector<int32_t> values(opt.size);
+
+        std::mt19937 rng(opt.seed);
+        std::uniform_int_distribution<int32_t> dist(-100000000, 100000000);
+
+        for (int32_t& value : values) value = dist(rng);
+
+        const auto t1 = std::chrono::steady_clock::now();
+        SortResult result = parallel_sort(std::move(values), 0, opt);
+        const auto t2 = std::chrono::steady_clock::now();
+
+        const double elapsed = std::chrono::duration<double>(t2 - t1).count();
+        const bool ok = std::is_sorted(result.values.begin(), result.values.end()) &&
+                        result.values.size() == opt.size;
+
+        if (opt.print) {
+            for (int32_t value : result.values) std::cout << value << ' ';
+            std::cout << '\n';
+        }
+
+        std::cerr << "STAT: program=pipe size=" << opt.size
+                  << " depth=" << opt.max_depth
+                  << " min_size=" << opt.min_size
+                  << " valid=" << (ok ? 1 : 0)
+                  << " time=" << elapsed << " sec\n";
+
+        return ok ? 0 : 3;
+    } catch (const std::exception& e) {
+        std::cerr << "ERROR: " << e.what() << "\n";
+        return 1;
+    }
+}
diff --git a/13comp/shm_sort b/13comp/shm_sort
new file mode 100755
index 0000000000000000000000000000000000000000..e9d778bd1c7fc904a39e01ea66404b15876b1709
GIT binary patch
literal 33560
zcmeHw4SZD9weOi^h74bsfPkr58R=l7Ld+x~Bp@{dGk8V@j3ihtqC=QW$Y?&s%mjng
z8cc#5hf!+1YSs49-qz=9?G?2}#IHaws1FdaDAlTH{WxP(P^+Y<%>A!@_MV&!b9^oL
z{eG{%_siDI+H38#*IIk+@3RkQ-{|qp&oY@L5wfKpNQ7-J*C>@d;ox;V0#GTHOE&zT
zCE2ABz|D-NrB`YIsalY;he9i-6PfZo$kWr|8Jtf*VIe`vXB5Jdv=jlQJPoIO7K+;G
z2f@yMQ_$nkZ~^uCn7%5`p9UY`1rku7k9-rpLdzF!8Vaqv5Hc}Q;C5yqN~F7azPouo
z0rQ9fK|tY85=VdQxj)mPgEAoqNW2sX(x1GPuoGb=qf(t~;RJm=-}*FY=llW+ebw(p
z>rO^r70-9@QcZ9=ypQV>Q0S}S`J~G@LmJ$`$pVV<U5b37YB<Zc0$zR6Vy@4q-Z%34
z6Oh^^1+sSn{;2vcTC_w8_x<^<H-G91P5#Im%l`DKJAT&i>XP#tLo3Tl&u^@o-WY0b
zYoFd;UN*g~v@p_ASj_U3Auq|(?9M~~JVPQH1?tX@rZMv#{Y%M#iFc2g$A}qzmcxMY
z8R(ay^JJp$gW;Lzb&!#Xeu{ydY4A%X{%Qld8FHp%u=9X{J>N6X+if6!zJdMc8pw&j
z@tN#D!+`&J1O8<O^c4o>y1{_{nE`#Sfjt)+&{rDJ8w}dXHUqzXVc_S-4eZP{kpHm(
z|GNhKP6PXYVPMZM4dg#+Krc3+_ZrAQ&7gia8_;(f`12zJy;TPELk9L-WI*3xpqIuu
zJO0wc?FM=`8Pv-Q2K@gEg2$x`2M+gS)H}_9-f!T~zZmHK5&SR?<K?DSO?e(EL<oX@
zmUODr!RO(8jVu*F4)J$fqY(tZ<oB;?YH9XIqP4A2zhCluYZm(Jf~~<-p-42?TC;Fo
zV@q?ergmjxP)p04vaC8<T;%sh8(Leg^*08aS4A8A!PeH6)~W>o$-it-b#$iRA82oP
zI-SKUYa^im6t;$%S9t@~QKvJ|P}}N{w$_HC5pTd#U5g)2g@2*HHXIH%*LfhL2|{YT
z)zOMzdmtE&hFY3IsB5fRO$m#tTN)#tkfz63(%RM>4K)Qd{qvlj#S2bCy+@Pw&ssgR
zH5duDt`2&*T~vxtGe}WylgG2Tx}^p#J{fnQ9G6s=YMEPfQtJk#q6$hy6@;2s*EWXg
z{I#vC+M0sR(UY!*vcWnq@-LH(%B|I^A1#XFE75|Q{ejwOpaB`F?$T-o)aqzy0Ih`Q
zsBLU)0Y55ESI4NjvH)6Db4!W;vSMd38f9(W8h-$+SC=%mT<clQ<P<wYEfGIjR?v?{
zM{8~C8n`_aMWTOId%HgzY>l)u!z0l({?$bp3*vTiQO+{IzXh!`SlcA3E<+<lU7|o*
zQ|8>>8h=fZ-&0-YuUb%D;%{VXT1vugQ4jTj>S$wxypYz~GYJaRK+Ft?`ET@{016Nd
zdKNcnE%Bf3f6gK_-MUaD+!6_L&y)sQ+M=4fQ+*v2e@nf;wYGUxaIhhu*QTl-MXnId
zvaw|qy8ht6z*<UuYj8-NFKNCug#3$x5j0&?U?|cOC@!G^Biho|*eFFBnrdMN4OxM!
z{egz7{q?mWMy`uW^)0PeOJKzql$I6s5o`}pMzjzbe`vsKstpkzHQ4$PHIVCql$%*d
zidF@qQd6)g&=e*R0hVr$bS;LhaHx*4h1Vb*nVVbutS!?x1u21OqXeaqXkFmE^Jx8B
zMrcziwkiO72y+rWpwTayH_u;ESR`HK^Uj^;FD@)8Pen^pG3Q{kWH4G>I78!Dx)dTx
z3rmWJpw0?u-qNM6xn94su%xhJNSZ!rNJ6nwk75$Z!Wups`vCg0uy{5gQHhp?Recul
z9K@{*9|?REsFXfh8iPOL8VhU$%V7aG<(H&fE`eq$;>}|J5k~W>NxBJZBr&g7oxNr>
z<+uklE!`q*<moFw*!q(@vAq~A{fg5jghFE_*ztRg-@($Y(qkO|1H*Hq9UN~vEi{sL
zIeUOpFrh>to<{iGfxBSxSn1E47Gn4qN#*#OmmY$BBc-DpS8hB9{3tQ3qB6Yv(A7w>
zNaHzv4a;wqzRU6GIk#hrmnBUDPC@L;#lCM-g+_1Z^Sz)~arz2A-wV3HA866?kyw#N
zl+8Li?e9d`s-vGKh=4sh`dK>qb2|ET9etmUUaX@Z)X__H^agG}EpMDUdRRw4S4S7?
z9ynE+si$*(qSM||1hIZ1y4ZWNw6MmJ1HhM7j9}H#sjZ5Tr=w#DnF{$jI+kFmVAs(}
zw+IC~I<In;RHUPmO(K-*=xC^^P^qJjN>TB=L`O%%Oob{PeN2ifNlSHfbevRJp`+)f
zsFKv6quX@!u#TRmqqpnm<8<^69bLaqU9Y2`qT}DFqfgY)@7B>L>FAqu^iy^82Xu6?
zcBbUbI{J5X{9ASO({=P79bG&Vq~zyx^zZ8U_vz?o>gWe`^vOE<AsyYWqpLdl6dnDD
zj{ZFzeLzQ_s-sK1zffB{TSvF*=-=1T^K|qA9X(%1KSxKm>*(j{=mk1D?Uh6*($NbA
z5wKiGKVL_$)X|G{bXi9))zPbT^cgz(aCF!M!yXv+z_15~JuvKnVGj&@;Qy@$KDV8D
zOz!;1D#t9_FTr-EyC<5J+$VSLwDvN?k~3ZaIXQJVer=O05hJ{T(h`S~2vc_uPFuRf
zK89~2oVId_9)>?cIBnq)n;HIF!fET4*u?N(5l&mS#72hSLpW{K5*-Y`op4$<C&CQB
zg>c$pCsr{0Cc<f}mZ)O*b%fIvEm6tvR>Em(mMCKQRfN-)EMaH(O2TO?mdIoHGQw#K
zmXH{}m~b26M~;Iq^<u*F2tUN|xrC1+d>_MS5l&mIL=VG@38$@9Vl%_fC7d1wBsMX8
z3gNWHN^E5KX@t|(D$&94@r2WsDiLP*D8gwgl~}>>EW&9Em8fF)u|>e?kwT)9;hzys
zTd715!#^aPwonN>!`~sCwoZvWhQCHQZJ81h!}k+TTcyO2Z>an)5N;>@5W{y6PLC=Q
z`xw5BaM~&*dKmr);j~3cY-adx33m{_iQ&H@oVH4djSRnsaM~gzIv9RC;j}eMgc*Jd
z;j|@6tYG*}gws|iQN{4<2&YFFiAvyr-x}ntR7ivy<?}AG$`$(}W2@x&oCNktD%qQu
zjUU%#UgZ_n5?75^`P&j%*;6emU&+c*)sM8kd3lnoyyaD%mE-gBWF_0#<BdnBgEr5q
zJ`LeM<wKwHK3LR^P$LueC1E!)?BL~BxR$%Fa9!CeLjuUNkwsPxtDggs$|cq4o=fX|
zF~?LYv`?vX$X?~^XQ&0L$G;}#XVuk!v2yi)0C;1|9acGhy~En)cH~RUE<_f_91dA=
zQ&J?$*+bDhbu!cS8kt8K)Wg8HQP-8@GYasONu&N5)c&mguuu6!BdllH`Uojde@7<7
zqmBYH`V%-rBS(46s$NC0nA;)O$>*6_8QLzEV-sgDU~0aW0g&@u;!=9G%rk-XXLHo5
z7O=F#>PAvEL{ikEzD`8=t(P(FQlI!rV_G_>Zs{{rCbgD0U~`fBDi@^VDJ2;<f<trc
zZ%9gf#+lek%gQcTqE??EH#$eXk}2<1Cy{7aHYhOqQ2*PSsAZa{?P!u*logczN8y8+
z7c(CWTtrE4sfV<pP=zx6Lj<<nPHuVwEd8%Tj{5Skbd|R5Ml>m{tZm$|8wd`OW9u3Z
zu7rzPU#!bv#Yi;hsWE8!b5Uk>B1}{}Sdr6sY~7u#fy_CL_&$aeS}`Nc9-pH@j@39;
zz;|X8n6<txM+fB~H&UZ}h?x|1<oQsZr<jWCL7tac*_Eg|cxtSdd1~)`>H&w<Eo9!?
zDcwi^PKD9wUXSr0lkO6|ZdXe8E@t})1$AOpgYKVD6OGSU%yrMoZ0JuluTZJgSIHhU
zW@Vqe>sdHD>3WKO<xbUP>%N&e<1KYOXX^YW8MRW~o&~|4?vHIsHxo7Emna14;}{x=
zdVn!ME630)-bz+soH;Bjed^Ohj?Xxbk%8L8LqOGAP?)W3KCZMO=M!9wazKt<@35<{
zGh9uqB!f<905Ie&wH*@FPVhPRJHK?pvWpN;Ttyks5zfuzthQpxcp+uHm=r)2Y=j36
zs8<1}I@>=0A?=zF(EIyUJ8{Ol92-&IzAnd|04RpmTy|+>Ix?z9{0<}qqcURa5u???
ziMBiC_>+zfB&j>eM5f)<d4nXiS<wRuT#5&osHq(!OFqFMrv3sk^=E`$48t^^z)@Td
zmG(g-%8JVCF;RhBT6^z2O2*IV#>@oQdzGE4lPD*6bP`(7C1^U}&2v-h{XiWct>0sU
z4*(}Mf26#Mn%K<-lC+lCb{?9+i)W)?S5l@ERE$INW=g&gQq&jd=h;lQ*t%y^Z;H>k
zjhM%0lyw8S$gbXms?o}M@0X-f*SD@h=1hI-RVI)3>-U&`a`x4kENMF(Ua9afuN<4J
z_33xW?y>Y^#gC@^%yi`sP0g%)nO=DVQ%TA{VfoYDIRna{L|vdtZs5v;EK52gIktp+
zH3D+fYv`vDKZ)<6mJ&1YqgmPhMVgC78d&)UriHs`2eXZ=lvylYIW?R~nw77*G#5QX
z7JLY8iF+}SB_3s?S$aMi!+#6|)JwsrK8YXA%Kd+XmGK#evGn2%wu30?t%;BCv5EK0
zV;;Jk>Ha{SN4lF?Nz*kJLgNJxt3E>lm0quMfOR{wTM24i&Zm5=t|YtLY2YrP*q;$g
ze9FdBG&ryFC+Y@2K#ET}l-N%LiHWhHjP-@K$zABzk~A0-6xR=3m+@uN+K=)vnJHMv
z)X6b3TWQc}LNgo|JiFYE%1!G`5=CU%j!>kE&I~ECw8A1uok^4J)`HPgY`0^DS2_9w
z4Wl$`*?m~yglYfd3-tSxsAI(?F~{MB-S67EUPsHLPF?*umEG+qr*&NCfX#OE&nR=}
zfT=CwvTZRtupGOF>0+Cu^=?O)bv0B;E>_3t=P<LYr|mm}C=u~ZMznQZLp2?r@fK+C
z^>g!()JytMom0rdUFsizI+N<h0Jh20YPx%D-8YTGzzRj0T9_mC$83{3D8ke@_tVO)
zT)m6c8_Enxv|2zJ$UL@iRcDbRMx=?o&z!|P(twhUuywsh14`#WmaXfnY!=J0b$Lgy
z*eF}~>1>X<-mzjE459A!3anKtK1(Lax^FO+cJ`VouwJ#@ItC?N5c3_z`n1c@!MGn}
z69buospLV8*!{e%>qhG9%8Rn%bL6Xk`IM|fjC{`gkFm*i^KDjUgUQylnqs7G8%4Bo
z+`)vowvtuO=jGU(EtSl?y0hRfDqu|GpyosKjk+59J2|G!E~KPNt~eZ>NbQ0856xe4
zJZw@gM9IjpD|{74qq(Fk%;?_-U6k~;Z5TI@LN={`n9Y@FnS^!Kuv#vCR)RI#I^a)K
z=yH_Lr94Z_FQMEtBcrzGlOop6lD4i&6l@#id75@R)EIJ*36-_<an^q0e_(}>6|GRV
z$x{7bKcY2CXP;HxuAV77_sOB2ppw%VpJ0_cx0__;vH^MR-@~ZmwpV?zD9pqJOs^>u
zX<_%5(Pg5xoUgl{L1nWZkhf7UpJv=`(%WBHo|Yz$I;Kv;nndY(gUprT61OtotN5JB
zwt0Gy@b!fl>MA~O-K8$3nvMG$l^$mg6&p()FUs}=DoqX?R7;TTgC8qxTdsF3r%JJQ
zeg$u|=1^t)krbe61HJWPq|h0qi^}l{eXOj3x#rFR<X>i%q}ce134J%b>v4XWSPWFF
zXH@Ij3#U(yglt_i;n!_w<<z7vz}8r;Kdd$Bb5Vn$qHkS+@#`OK(rc+5h$cM}!ZI}J
zBt|G2PHf$+P;J{{@?n%JU(cJLzG3^|jC^Xxz8LQ|q8%^#gqo0ys?5id%pJ2Ud0N-R
zmSaDuRd)DhH#*8~UAI9;%p-LUOtE!6ifOC6r)_XJSJ1Z9+rgj6MPt^+8yK*{_Lx*Z
zXL@t=Z2Z>Qx;})55Non^kEg*t56;<GzxGD+bwOMAQ~J)o4MWT&vAX|5=V!z17<h_?
z+jl=EYvBM|im>7K7E}uPr)@cg+X;^KcktokL#;>8*?)l~4R(3n!Q(T+-$gdzpIh-9
zNZ-#Z(a&w&`7k`;zz@0(I%@QHXo?9p)UCZS8!t~b*t%B%N!9xYaMwRr@7J+@%!jgZ
zRHPG!vX#7Cw(d&AY+J?+mW;Ikt)hSJ=zzCb&8JGU;v*7>x@L6@ufbO_$+gP^PV_>o
ziPb%55Wd-URO9p}xhu9r>O6)jrzOqfVCs-f+vV*EyREw(l<xglN@LUSQf^4O31VdC
zrOz;DCywKXw+HllF~7`&7P6`X5(lRkt>tQuN7O$tTWRXyV{gKP7E-^F4X4!a>Vmee
z4Iphp|E7NT5*}&EnC$b^M8DSge$Uo`pkT^dZo&|3>s~`P-GraiD8L5V?T~{yWbW(t
zFnd{?l#$VxSqgkgAM>Vq9cyVrji-SppXv%vJyOMxmAzUHt0)U+)7o018d|*-&$(=O
z^i_6Yq`4Ob@x`Yen~iDt`(l*ZhB`*^qK=s~kmr)5z<qC+E788bN=E0z{=kM#>H#~L
z7AovayBu4r%AMEe<w<Q%KW!%o$b9LCLo&DZ;u&uo%8;XclpL#6y`9&a^CVlBi&_{h
z1ekJ?eJ5N>)0eg0cDQF7J$xjO<Dnu}A6KCt`OX>mOtzid^O@~R%PpvgdfE2lUUdb_
zMbkuljvHL+Gq6C^*Y7B|woxhvADX31n!ZL{tPVB~vP|Tns)(muC+6Bgo=-tWSO1b&
z{zzi@h`fA|WiMD@TXQe*xQNH1mE}T>NBun*&=S<&AWiIc|Bd8!95;QZr}I!YHAnu8
zWCB}K+PX{0U2AvJVpBZ4bNPFpro{xQc}+!|dj@rlA)1fQi7vMA*Y$|0RKD~c!TSD?
z_M|?QfUx<LTRGg{Z`?=^uyXt}jWhtstbHbWX!4;IuN<#&l%b;E!P8~xrs&#s_3Dv$
zlKLl_Y-ze--RCwoTOID-yp<Nz2`|iB*xiGse0~Ln5Z=7IZ>3GrWBBnYM-!VddZ<NE
ziB&!}|B1*E9^IFCAA>_;8BHcrXvWvls|VBjDE&X_=O#=ObY9{7*sHvBrL4RocfNb1
zs)p7F&!fqGisa<P*YVcb-*oGn_?(~M{WLjlxrIQ*Ky)Iy!Co-YNIo)oh_8ox#kx2?
zr<U>0SVrKS<Fax@-u}sj^7esj+0-Y$bUZo%0)EZ~Sd)h^v|zn0@{@fXbC%3PV`wW`
zB6rT23r=|Rz35o1Ge5yAbjgWDAgKWu+h>^uM$;9&gZ4sBrG9-z@)E1SJIFE^!+hjb
z_H`alMrAqBCkI}U1MXe4jER<u@gzmDv6vjFd6gL2K9J+)S6xa`tjes6+f`|Xh9q=L
zAnh_SL@Sqa#HGAM8m@6EpLQNgMnm$h?Ue3%oPPTq+;6T}*zCeHqv#^V{i0b8Jf|EX
zJBlgG<#OPNFK#|62R@VIrAOVdNuG+lAMc5+)^bc!YADAG%4cNQUdmx6l3RJMcO#SJ
zQl9UBShI)m5&laJCnbAGC2_-kdRlJB{_hOF|67i68V~ESj+{WvI}dw3cFY4ffeN5L
zfu4$vmq)grA_um2Uf*j@Mn@`p)rXO+Y{xo!0-1EC9N3|yO;BFJ!!FDbW7J#0g3M!-
z9W+|z4?ak>;RMZ2TzfB1JPr+N>H9P>R$}1z=x){^mOC1B+f?j8ojq`~t&2UPQ5tFc
z^_6nKt2|Fn{M%8z&i%gl|D<JYy?%Y|4Y+rj<<1=@^4(`(>wL18W{YHWgsUQCz42P~
z4v+JBwv%;rUcb`}6+IZhFjDyxv%`mCSk+yy&=)g1<QVk&V$i4b$y;G2I{~BPir2hn
z^>{}faVtGE>(OKGF?=-q0k#4%&Kw#rBvQ#}!Hxdlt++HV(n)@Ikl*c0pSBuxLoeLV
zPTv3>tQtx&P`F{jytrG+!iHx~5*r2EZL^rE+6Km_jDfvRvSpom$6v|hF^=vYm(pij
z|6^F;ihGg}?dkr~)>Q(W%7*7pj1e*7++|yzfJ9r@L->X60xBaQdoxa3trWO%uv7Lf
zTT-lF1U8L4&8;NW$(%eH<oct?eq++sJqhDIA=3zX`UA}IfoC<Rqs*}hopONOjAlpn
z<i|=oSzW0Af%Rm3VHOR+dCc$f%YS9A7mIeRKVrP#*m<%&W@o=CQAaZi)}g7YN-PEi
zPVb_!NYKpWCoTXL)ncb*!vySuw8}@rep5XN)k-fKwu2h>sc6_dag6c`&0t$8eFr2d
zZ=&h&mcpcJ%|*p(erR(Uv^lYp?Fc0GuWw^3RBpC)zYIeXk1?y!F4X@m=)Weqc9cY|
zj#{}-(OQU45jD<h`^$IOiop?IV)7`ePkEl6Hb2bFgtrwq8Ezard}-T@opUQHo|@h?
z%xD#~e`iNO_p#<Wg!z|R%5A7z$d65PU~Pi-N;+JMs$R_0$Qjhwx@i!HsvMoFo%BSB
zsdAp6%GO<s3|guk>JkgyV>4bN$l(=$i8C=&Y!vm0;j93?+J_Or?hAY<D|lMsJqIU+
zz3kvp1|3gFzVTJ4k(#a4le`tr+PeM|ErC3m@BDHb5ow9@hz4DFQoRe$7JSOv^7gmw
zSl`=j@3C#^@mB0<eF<}7+iq%w`Tf;eKW0)E#)BsHc4YF}9@;4@+uaq1BIml5L(ct2
z54w*2&7~Zucq#H7ZQTz|blRWdR9in{0%;c!H;<-vi}sFE_z<&Wm@HsZo?3!T5Z(W}
zetN5v==q*kIqq8GRrcU86l(_>;j!$F;xV5ub^#lOeAox%d$8nfev90T2dpSCcDL}-
zF4imD$}v|GqxN=cCwX#(8oe}j3N|{?84J5Vj^@bcs9u~7V0)A8R=$@uluscWW#u{D
zT5l*v^epwVL(mJ+x*4FKHWOC$L0Hs})i%X9fva=2#Ff-AZf#N7_7pAHC3Fpb;7e23
zG(LqjVhW45ph)M-G_>7=5^3kpIE_~S@+Q?T6$*vJKKR-nusv{*wg;}p_5dqhI*U#-
zZxu~YR3tuL(`xAD{&O}m@6i_ME%r!7y`Gf}lLSt->4_8bpF#)SIDmQqC&%h(<a0)j
zo!5{3n%)aIpPkLBWX?yqv>$-6`s&4aKxgV-qgubHmScV>IjWAL5>@oF=_hJsCStr}
zCt7m%>(NiVu?ujL{hF+Nq8@%DnY{c84D8Eocl4kcL7p#`BP+*z@!Rt0Igs*q+Q!9P
z^f=2ZuYDh`>+mT(Q<HSwKk^8U&^iy9<f8}Wmp+k89$taBLZ-g8+4?iti6j@EOg-QB
zj2wH6MET-3Q}RYx`BaWQVkhC9J0S9H5{We;7x^5jL5NJqB^M8Hd7$5vhfLmzeQi(5
zv76iRLWmqYRo-=T2Y>5+ErvK4HI>O5xerfbgq#oMlDl-KA&F(z%8Sl`jVO~M&uPJk
zbL~PoUS*PFW~|@uBH^fLEP-~&+dmww?3bN8=!xI<Lpf7BE}QmqdgMn*@7UJ9gN@-~
zk*tnK3hS4&#kQ*VW2|Ovn5*i)H}&37r+8Bch7X5f4-9)?*aO2J81}%h2ZlW`?15nq
z413^T+5;y1TX_8kWM<9MK2X9w{9tbk)@z@Du(yU*HAE%C?SY0+W1XG85fQAD7=0*-
z&dBlE2RgFD;i%LUibU{b8aqCq(iXJidlGhh5kmX$M6@LYwnz|i7zs!iU$Kb-HUt~P
z()0$Yt@&zvm897&KD;u^E?ur=u~%PVN0eo_VwA*`*_+xTQTxiEy}6}%dUJ49Z8WqR
zAE1CasT6#FBcxH;XD_O2Ts5=o;ntQ_t+h>a@VcR$xaUZACJ(R)UtQrO_6Zn}=xaCt
zkziny<XOD<lEpA;`gAaA1!wg=#HaQ^OEbQL(H5W&?bz#ETbk_6`0|E56oH{p@(jLr
zp@k)p+Eu|>_QLaFia*lQ8l^I_0xV+1)r#q6aiP(^@CrN6&OmU_9+&C#?AiALqko7X
z?@cE60T#TJOpd{$%Y}e+eElpSJq!L~e=_+IwvLWJC6iy{F^u|JGWh`DK|F|}ZMceu
zngb*UPde9we*o}4z`Jpt6Ggt~a6;M+{^xK=a|HCQILxU8{Q(@}<bggwhdCto(`1sq
zFGm4~XDpbmTP&H{^Gv6Y$+2!kUZS6YzkKLEn>gG#c%Y_zx3Cm2yazTzwv?MUKR5qk
z+vsbp9nyuT%|5rpF@^Yuc{%=6<X=Vv1d<shxDWq)fe1CZdA?jL(?h7~x+)*DBIn*(
z{KJRSg)Nmxb5J_+wF8>{Fn(@s-mO`l-28a<++6zxvpct7oyDD7)Hx!{H!8Qlm201y
zn-8A3xmFk6BxCk`1h^IU{2q{koqkZ(8u*p!NOI-ob!I_G*3F}+SXR$yX&T6z@b}G&
z$z&0D&4*EF$c<+~{)TMmS!Z_T7IZ>)2a+Wp{-}=k;Z*ntp!sq$<G+pgZ_W1P;^CVo
zw_t<Cm0PrKggdvqGsm5~A}c&9w;YNg38m3nUIZDxhTt&j_HD#T_l7K2ZvHyb-HCEn
zW(7y(+ChQ!DD6d~r6|~Hkmn4P>-$h|{vm9>D0h=-X=l!&bt5j>V9BcQ^X$G3%pk5C
zvBA<3H-~S{zAY>3<vw}0yyxP*@{2yAd%$)%MdIeHI>eErVZ?lO-|jtoUtBpzutV=|
z=%so(AJBXX^g=^t&L9u99crr^QJw{eYvplMdE8W<AC3|QagSccqHeSht^OWFz6X%6
zpYkE(<B!^47uq|u3kecdj>@%OhYF{9`wP-!9LRpAr4`BXtOcExh3m|hZ^&M=d*O!c
zEcfnZ;72t}Rp40<{_<B*Z@|r+C;)uT>kYLMH_uJgn~Uo0qTGE2*-fKRbEwM`Yfful
zWP=_4cwhu%-V2$?r1uAzM&X?|vn|=u0KUkgy;e=_odVUr`2{?ZLdZj$PPYZV8M5h}
zfG9n(LSX$AILHXu__S#jHE%@o@Ohg2EPN;pBC@UcLJgpCS~6*}mY;?38jmaypX5Jp
zgGsv6WI1k<Hk&MmP11*^`6M=ZuhaDX-(+K$cwvMiZZ#!GAj8jcEcaNYhjR*kWi@@6
z1HyW%1)q9hcCb9>n9lsJrA@jJNtauCP15})%ljtjX%o(Xlq}1w+$>Fg$h3UGG@<X*
z?44Pb_fIvwXSQrUHTy`8<@Hldd&XGyotph?+YS?w-x#;k1lpsgSe`i5^vo%g{tAo#
z^%NiCPfsBFPbLz5%fuzfaA*=yVAKsz^b!8mR`TA>CeyD?r&$u&*>f##WSQD58%Jc{
zWU|CYWIt{q>Zc~lQFHcjljSvY_8+qfK>2O<d5@T-yUahp5N)yi`-tqlBP?rkvX73S
z{14|i-mqkUlVdqBCi@<%W!>29Jyy%wvDvR#Enknxj*ldfFO0N2H7fhnk(RBavTqsX
z0OiOi%QK_1zZqrOHadIr=n_zpqb>h2Hv7RbBy-;wlE$nqC!3R|(cYU)J55r*3EpG@
z-JP`=!s+{^SshXj(S-l;ogs$fZ2}hH?jh;KOYMyKDL)0G(cf?w_Q0?QhCT5Ag9pU-
z#l-i-jLIa&P5L$(1%bDx;q>h`eL8)sjlviWNRnNP;Kf!J%H0~oFwTPb{uy54V}aH@
z6i(BCB))@2YjO%A{fpzt7Q&z7>v^tLs^SAYmK`h%@N`-~P$=gKSn9AqYbgp7HIVw{
z*(8-|5o-(R=Mw_0=_%k$jRjhdP+<S^8c@*1$7F@w>>pnsUCcv5KVE6znzSO~z)Qnv
zQbNEohvCAmBOG6E)6(%u+>msQ`mggVz8{}%QJGz%%;)ej4(mBw&EYx@@8s})4!3aF
z$Kfj+zR%&89F90kVqp@8XLDG_;d~A+<FKB?)f}$l@J<fz=Wq*$eH^~R;rkqZ$>E48
zTtA0rb6CdVd=4+;u%5%!9IoT=P7d$qa0`ch9KOP#rcIK>_W=biAihR9%U*z$&N+5x
zS)sGgX)i7+E-NZ6DH0r+p$TNO^eO#Ik0F8Dvk5z0@g06UPo>l4O#GCdg;AmhuWV8f
zdu17MqSHS=qA*nh(oX=1K9$qiz6Z1qINd%=V-$N_8nB3eAE&c@E?Caw^q+G%w6~=Y
z<n-`t4X6Dhh1)rOk3++0e@6j}PbPm8{=EnVw$}o@Jxim1%?+ph4+VPfCzBr@;QWWm
zH9qnCTTaj8{t@)2I6Zy*ei?KVo+xaNXq?<k=`BW|lp05coDmpE$UkB}5cKh&n=l%R
zaaquvpl7mwHsjBe2DBx!U}rEBzZd*?0ZtP4Cx{I6T*ic*ZTdJ7Wc1Tg<FMfW5$N=6
zDLwoY^eI&DbG4Ly&QOT@%*4L{^gQWwsr{OvlIY*vWa1AP(DO0D*db?Wnw-ZB_;-Uo
zPQptmRhnL)EWB>OZ@~nY$(|{oPvLp>V2%NQl>t4#=;)9100DuX1yG<bqh!*%!GONS
zfc`w_<FZaaVLW=pfPV`5O(wlF4Cn#S&w_mM9Z@mg-e|yozXAP41Nvd2XN{G_`bF~&
zo?RO7kI%_$|Jergas&DT(5YPFyQ!jF0nn+P_sr8Q5#!+*XourL7x(9!%?<tBK>kb!
z%;aaE0sR^S`UawBu}&ad!ytX_mg+sdfBnKhP8jVjlRd`__!na0$;3}z`OWlw{2M_h
zzio7BX1>j>ebzwE-wo)KP*fT>();`O82t=sD<6l2GYVL}2y76}GN9LSIUQ-^N!Wn@
zJ_CBc0e!rIpIZ#*YYpi48PJ~uJ(HiaFtul@ukRSp&j;N;=&n?3fdT(Y1Nt8g=(|84
zmy$Xdc^7p1AexGOZa^Q44Nj(VT>(1zVN<0h;s}@YbI>#0_wXp_neKZyU?Bepm*2tX
zy9L71>OgDMS=fT_m)EWg`J=U~=)>jgM5izi4&$ruK4(!Rj4$Zp^XZXjRq3LZx?pH=
zsM_f-WT!<qk_zK%<tKHyf$oxlrovF9wU!C0j)ohJ?}xy}00x&cu+Q+<IQ<@69D%Rs
zFJ4ex?jMxub2^)Xt*hvsfJijL%RzTXpnUYr_C{7_PA?4OBk{}_WYaFUU|)AX=_@6C
z&Ju{kO$R})$5~X3%P)d;?%HT=D71LN%uCqq77@*&f0P+j&{(JWzPPllIfPS7y1XDt
zAMnRL8!OxBAkQ1}1R8MzL2(Hj5D7Ln2mR4&*)1P_T-Xt64tkq>O(n%1UsG9eDSk^T
zX40<{KgBc3W|o$hlsRVraT2ApxT3V8Y-Vu<QHZa&tfZ`>xV)^ih**ePT2x#-v!rO|
z3=-)qXFty3(vp(m86_Ts(Bc|Y&Z6ofzq5#((&Ue>2?sr*s_4`FTDj0N*=-WlXr6;t
zllY@ebPYsvFoHH)*WzE**s>C}R~Kz*jreQZ+ND5CQ@Al04c1WwX5yev{)ccyMr-XF
zcp%!kMyiJuL4RFaQxkp2Ux%^VB!;lUDBN;DCi(sI7rPdE{GLT_x<JK`O_JXubE52C
zEcxC4w#c>6J5Tao<hx|9%jdsj{`_hWnyG89&%>|u(5{K7WFPz2zS_^L^IxK}oK9Q@
zu`1Y1_dL|mZ4haf9B6jqk^;JUz#ptbV`c~PL+K}T?@8J<FnR|S7CTdSH4Ihcy#&`g
z)Zrk!ErO$ZHYBB8K7#91a9c&Xv=eSFsT{l~0cF<T5-~)fcHhJhl6GmtP}1OC6DMAE
zGDOq2-KL|rncqn<L<?Gaq{ZKWdZHV9PR8Z@su{f^=4y5u#!y{k=(pWDqn9DMe^}TW
ztS>aYkwt&4jkqjFF90`H&@C!Pw~6RkMP&`SS!9Tdsq2G_uG`RE1(GTqF4N%mdZb9y
zw5e9ZYf>cKzJW;+w|k^0#3agj;)O++v;H*(-#{b3(&Z$sq|wTn8l%`HOgh)HT0%k7
zIvicEGc;$~{VgdMmP%}}Mdje~DKV&0z5n03mq%}gu-0HHk>TPW?RKi6x8n?vh*2s1
zj+j*0aEFU_>k+Qa(Pui@j_SodL$u5ZV3AY8Z<Z?i_Un@LY721_OuDUuZJCVq(@?H;
z5RB{1c<+hcLQ0i~4fjJvtF-%o^x7b8Wh5emQ7(f^oAjCJ?wXSt#RhNU8X}Hr2ZN%1
ztPxje4dJ7)=EPQf(zl5Xkxe$xRYV$5%$jU^NnM<z>rwFAiFa5HNk6GkzBs+{Fay{k
zH(fZpUQJ(wZ@(sP$OTT7;vS=uszsXq2XC^{o4}`}x->7Q4Z8Xq<i``Px-+=W&UklW
zI3(ycF?y|JCyI_MuvRs<!Nu(u#_;lBt#{3uz{MdfgK=kA)%+S<_Ju7=RTa9iJ6u!j
zr%p{*fHhTDP`~CkrRfEOn&DQpp&Uc*&KlaYAu@Q4@%C!vw{3CKc36^B7+KR4tz8L-
zOS%|r5HY+k7%W853s<(`HO%RFaj*~@lVEFDV$_D(NP|>Zx272qG#G8wQdVP=LicAe
zHjem_)*5WAr3^e4Zj6#dT<ldC4YuQ#&FqD(Eo>257;NCn_=Y;<6&MU<i+c#i)mz$q
zbJ+9JC5MG6gK0;Li~H7a67I{IPTOLpOxp@*%0!$Ll6BC{N>bYt3P3>%Y{E|=GgLDQ
z!=Qw%O%vVBC-&d}O-SdVcw~oX^jcVt=h_qmbZBVmS3Ex!ghE72_!Idb<oN{@=c$69
zc=dt48i6nF(ZA?pL7cM+D2|DQUOb)~5-Ne=5l~9MIENK*DW3aMAV9iBesLZugGMF`
z{o-6#Kyi)>78cU&r^o7aW-9WFb5a3Yc|Kvk;1lo)q|+I!z}d?|lqZj8<O<1tvQya4
zQ>8{kNOmf}c*w+|I0qK`MSfBK)ja=PE>N5+3n<Q^DL<W+r|0hgjZDPjX)V}?LUG>C
zsmxXpC-@`$>GRv|M3p1~dr}3{=)x@mt^--0U!3O&Sbmn4PyAMj2!|U0_4&nfcLDL(
zYe*1&6vW#Rq5LT`sX<WS@E|4Xg7BXp-Ghiezc{ZFP@E?U{&f8hq~&j4tZ@q1#rvbk
zpRWHAB;c!vgYEA!&dFg|WaKbC|2EL|_HW?%1bi&5{OR`ZMt=SHlYT#YCD$uJy8gG)
z@{4m}0qr6qhw1u11|6qktZxyEIFA(fny2d%xPX609(pxGxLLeM(oP*4LGWqVATH<@
z_=j91@{4=uI(UB3Pep#w?gc&`nW^uI{Nh~mZk|7nH%vYZrtA@NPEXS>?)Q7ZuW2Y3
ziZ~Q@3usTvFWzHOdHygJP8UQz0nbUxFU~oZ)@qsTy1Wz>`2?BH$%!V)FU~RAdH(WL
z$JBCEii{l6N3QTcd#6*MB=V<^U&Kp657Shz^t)>rka}>gLt!%hXf71?i+ZJGVLPI!
gu=HvzI)@skE(pDXM8kZh{Qtg2<Cv3{Aq|!O3+}?p?*IS*

literal 0
HcmV?d00001

diff --git a/13comp/shm_sort.cpp b/13comp/shm_sort.cpp
new file mode 100644
index 0000000..19b83dd
--- /dev/null
+++ b/13comp/shm_sort.cpp
@@ -0,0 +1,295 @@
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+constexpr int NIL = -1;
+constexpr int MAX_RESULT_SLOTS = 4096;
+
+struct Node {
+    int32_t value;
+    int next;
+};
+
+struct SharedData {
+    int results[MAX_RESULT_SLOTS];
+    Node nodes[1];
+};
+
+struct Options {
+    size_t size = 100000;
+    int max_depth = 3;
+    size_t min_size = 4096;
+    unsigned seed = 1337;
+    bool print = false;
+};
+
+struct SortResult {
+    int head = NIL;
+    uint64_t processes = 1;
+};
+
+static void throw_errno(const std::string& what) {
+    throw std::runtime_error(what + ": " + std::strerror(errno));
+}
+
+static int merge_lists(Node* nodes, int left, int right) {
+    if (left == NIL) return right;
+    if (right == NIL) return left;
+
+    int head = NIL;
+    int tail = NIL;
+
+    auto append = [&](int idx) {
+        if (head == NIL) {
+            head = idx;
+            tail = idx;
+        } else {
+            nodes[tail].next = idx;
+            tail = idx;
+        }
+    };
+
+    while (left != NIL && right != NIL) {
+        if (nodes[left].value <= nodes[right].value) {
+            int next = nodes[left].next;
+            append(left);
+            left = next;
+        } else {
+            int next = nodes[right].next;
+            append(right);
+            right = next;
+        }
+    }
+
+    if (left != NIL) nodes[tail].next = left;
+    if (right != NIL) nodes[tail].next = right;
+    return head;
+}
+
+static void split_list(Node* nodes, int head, int& left, int& right) {
+    if (head == NIL || nodes[head].next == NIL) {
+        left = head;
+        right = NIL;
+        return;
+    }
+
+    int slow = head;
+    int fast = nodes[head].next;
+
+    while (fast != NIL) {
+        fast = nodes[fast].next;
+        if (fast != NIL) {
+            slow = nodes[slow].next;
+            fast = nodes[fast].next;
+        }
+    }
+
+    left = head;
+    right = nodes[slow].next;
+    nodes[slow].next = NIL;
+}
+
+static int local_sort(Node* nodes, int head) {
+    if (head == NIL || nodes[head].next == NIL) return head;
+
+    int left = NIL;
+    int right = NIL;
+    split_list(nodes, head, left, right);
+    left = local_sort(nodes, left);
+    right = local_sort(nodes, right);
+    return merge_lists(nodes, left, right);
+}
+
+static size_t list_length(const Node* nodes, int head) {
+    size_t n = 0;
+    while (head != NIL) {
+        ++n;
+        head = nodes[head].next;
+    }
+    return n;
+}
+
+static SortResult parallel_sort(SharedData* data,
+                                int head,
+                                int depth,
+                                const Options& opt,
+                                int slot) {
+    const size_t n = list_length(data->nodes, head);
+
+    if (head == NIL || data->nodes[head].next == NIL ||
+        depth >= opt.max_depth || n <= opt.min_size) {
+        return {local_sort(data->nodes, head), 1};
+    }
+
+    int left = NIL;
+    int right = NIL;
+    split_list(data->nodes, head, left, right);
+
+    const int left_slot = slot * 2 + 1;
+    const int right_slot = slot * 2 + 2;
+
+    if (right_slot >= MAX_RESULT_SLOTS) {
+        int sorted_left = local_sort(data->nodes, left);
+        int sorted_right = local_sort(data->nodes, right);
+        return {merge_lists(data->nodes, sorted_left, sorted_right), 1};
+    }
+
+    pid_t left_pid = fork();
+    if (left_pid < 0) throw_errno("fork left");
+
+    if (left_pid == 0) {
+        try {
+            SortResult r = parallel_sort(data, left, depth + 1, opt, left_slot);
+            data->results[left_slot] = r.head;
+            _exit(0);
+        } catch (...) {
+            _exit(2);
+        }
+    }
+
+    pid_t right_pid = fork();
+    if (right_pid < 0) throw_errno("fork right");
+
+    if (right_pid == 0) {
+        try {
+            SortResult r = parallel_sort(data, right, depth + 1, opt, right_slot);
+            data->results[right_slot] = r.head;
+            _exit(0);
+        } catch (...) {
+            _exit(2);
+        }
+    }
+
+    int left_status = 0;
+    int right_status = 0;
+
+    while (waitpid(left_pid, &left_status, 0) < 0 && errno == EINTR) {}
+    while (waitpid(right_pid, &right_status, 0) < 0 && errno == EINTR) {}
+
+    if (!WIFEXITED(left_status) || WEXITSTATUS(left_status) != 0) {
+        throw std::runtime_error("left child failed");
+    }
+    if (!WIFEXITED(right_status) || WEXITSTATUS(right_status) != 0) {
+        throw std::runtime_error("right child failed");
+    }
+
+    return {merge_lists(data->nodes, data->results[left_slot], data->results[right_slot]),
+            static_cast<uint64_t>((1ULL << (depth + 2)) - 1ULL)};
+}
+
+static Options parse_args(int argc, char** argv) {
+    Options opt;
+
+    for (int i = 1; i < argc; ++i) {
+        std::string s = argv[i];
+
+        auto value = [&](const std::string& name) -> std::string {
+            if (i + 1 >= argc) throw std::runtime_error("missing value for " + name);
+            return argv[++i];
+        };
+
+        if (s == "--size" || s == "-n") {
+            opt.size = std::stoull(value(s));
+        } else if (s == "--depth" || s == "-d") {
+            opt.max_depth = std::stoi(value(s));
+        } else if (s == "--min-size" || s == "-m") {
+            opt.min_size = std::stoull(value(s));
+        } else if (s == "--seed") {
+            opt.seed = static_cast<unsigned>(std::stoul(value(s)));
+        } else if (s == "--print") {
+            opt.print = true;
+        } else if (s == "--help" || s == "-h") {
+            std::cout << "Usage: ./shm_sort [--size N] [--depth D] [--min-size M] "
+                      << "[--seed S] [--print]\n";
+            std::exit(0);
+        } else {
+            throw std::runtime_error("unknown argument: " + s);
+        }
+    }
+
+    if (opt.max_depth < 0) throw std::runtime_error("depth must be non-negative");
+    if (opt.size == 0) throw std::runtime_error("size must be positive");
+    return opt;
+}
+
+static bool is_sorted_list(const Node* nodes, int head, size_t expected) {
+    size_t seen = 0;
+    int32_t prev = 0;
+    bool first = true;
+
+    while (head != NIL) {
+        if (!first && prev > nodes[head].value) return false;
+        first = false;
+        prev = nodes[head].value;
+        head = nodes[head].next;
+        ++seen;
+    }
+
+    return seen == expected;
+}
+
+int main(int argc, char** argv) {
+    int shmid = -1;
+    SharedData* data = reinterpret_cast<SharedData*>(-1);
+
+    try {
+        Options opt = parse_args(argc, argv);
+        const size_t shm_size = sizeof(SharedData) + sizeof(Node) * (opt.size - 1);
+
+        shmid = shmget(IPC_PRIVATE, shm_size, IPC_CREAT | 0600);
+        if (shmid < 0) throw_errno("shmget");
+
+        data = static_cast<SharedData*>(shmat(shmid, nullptr, 0));
+        if (data == reinterpret_cast<SharedData*>(-1)) throw_errno("shmat");
+
+        std::fill(data->results, data->results + MAX_RESULT_SLOTS, NIL);
+
+        std::mt19937 rng(opt.seed);
+        std::uniform_int_distribution<int32_t> dist(-100000000, 100000000);
+
+        for (size_t i = 0; i < opt.size; ++i) {
+            data->nodes[i].value = dist(rng);
+            data->nodes[i].next = (i + 1 == opt.size) ? NIL : static_cast<int>(i + 1);
+        }
+
+        const auto t1 = std::chrono::steady_clock::now();
+        SortResult result = parallel_sort(data, 0, 0, opt, 0);
+        const auto t2 = std::chrono::steady_clock::now();
+
+        const double elapsed = std::chrono::duration<double>(t2 - t1).count();
+        const bool ok = is_sorted_list(data->nodes, result.head, opt.size);
+
+        if (opt.print) {
+            for (int cur = result.head; cur != NIL; cur = data->nodes[cur].next) {
+                std::cout << data->nodes[cur].value << ' ';
+            }
+            std::cout << '\n';
+        }
+
+        std::cerr << "STAT: program=shm size=" << opt.size
+                  << " depth=" << opt.max_depth
+                  << " min_size=" << opt.min_size
+                  << " valid=" << (ok ? 1 : 0)
+                  << " time=" << elapsed << " sec\n";
+
+        shmdt(data);
+        shmctl(shmid, IPC_RMID, nullptr);
+        return ok ? 0 : 3;
+    } catch (const std::exception& e) {
+        if (data != reinterpret_cast<SharedData*>(-1)) shmdt(data);
+        if (shmid >= 0) shmctl(shmid, IPC_RMID, nullptr);
+        std::cerr << "ERROR: " << e.what() << "\n";
+        return 1;
+    }
+}