使用C++ Bot和C++裁判程序的时候，Bot出错退出会导致裁判程序RE

[qwertycxz]

报stream close，不知为何

[qwertycxz]

[bkmashiro]

这个错误重构的时候好像发现了,但是我忘记是什么了.
可能是重定向的标准输入输出没有正确关闭的?

[qwertycxz]

出现错误的裁判程序

#if __cplusplus < 201700L
#error "Your C++ Std Must Be At Least C++17"
#endif
#if __cplusplus < 202100L
#warning "Some Functionality May Be Missing Unless You Use C++23"
#endif

#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <string>
#include <deque>
#include <vector>
#include <cstddef>
#include <cstdlib>
#include <random>
#include <sstream>

#if __cplusplus >= 202300L

#include <print>
#define CPP23CONSTEXPR constexpr
#define CPP17FIXME
#else
#define CPP23CONSTEXPR const
#define CPP17FIXME inline
#endif

#include <nlohmann/json.hpp>
constexpr char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                "abcdefghijklmnopqrstuvwxyz"
                                "0123456789+/";

class LZ {
    static std::string compressLZ77(const std::string& input) {
        std::string tokens;
        const int windowSize = 128;
        size_t i = 0;
        while (i < input.size()) {
            int bestLength = 0;
            int bestOffset = 0;
            int startWindow = std::max(0, static_cast<int>(i) - windowSize);
            for (int j = startWindow; j < static_cast<int>(i); j++) {
                int length = 0;
                while (i + length < input.size() && input[j + length] == input[i + length] && length < windowSize) {
                    length++;
                }
                if (length > bestLength) {
                    bestLength = length;
                    bestOffset = i - j;
                }
            }
            if (bestLength >= 3) {
                unsigned char firstByte = static_cast<unsigned char>((bestOffset - 1) & 0x7F);
                unsigned char secondByte = static_cast<unsigned char>(bestLength);
                tokens.push_back(firstByte);
                tokens.push_back(secondByte);
                i += bestLength;
            } else {
                unsigned char token = 0x80 | (static_cast<unsigned char>(input[i]) & 0x7F);
                tokens.push_back(token);
                ++i;
            }
        }
        return tokens;
    }

    static std::string decompressLZ77(const std::string& input) {
        std::string output;
        size_t i = 0;
        while (i < input.size()) {
            unsigned char token = static_cast<unsigned char>(input[i]);
            if (token & 0x80) {
                char literal = token & 0x7F;
                output.push_back(literal);
                ++i;
            } else {
                if (i + 1 >= input.size()) {
                    break;
                }
                unsigned char storedOffset = token & 0x7F;
                int offset = storedOffset + 1;
                unsigned char length = static_cast<unsigned char>(input[i + 1]);
                size_t start = output.size() - offset;
                for (int j = 0; j < length; j++) {
                    output.push_back(output[start + j]);
                }
                i += 2;
            }
        }
        return output;
    }
    static std::string base64_encode(const std::string& in) {
        std::string out;
        int val = 0, valb = -6;
        for (unsigned char c : in) {
            val = (val << 8) + c;
            valb += 8;
            while (valb >= 0) {
                out.push_back(base64_chars[(val >> valb) & 0x3F]);
                valb -= 6;
            }
        }
        if (valb > -6) {
            out.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
        }
        while (out.size() % 4) {
            out.push_back('=');
        }
        return out;
    }

    static std::string base64_decode(const std::string& in) {
        std::string out;
        std::vector<int> T(256, -1);
        for (int i = 0; i < 64; i++) {
            T[base64_chars[i]] = i;
        }

        int val = 0, valb = -8;
        for (unsigned char c : in) {
            if (T[c] == -1)
                break;
            val = (val << 6) + T[c];
            valb += 6;
            if (valb >= 0) {
                out.push_back(char((val >> valb) & 0xFF));
                valb -= 8;
            }
        }
        return out;
    }
    public:
    static std::string compress(std ::string const& str) {
        return base64_encode(compressLZ77(str));
    }

    static std::string decompress(std::string const& str) {
        return decompress(base64_decode(str));
    }
};
constexpr size_t seed = 114514L * 1919810L;
static std::mt19937_64 grng{seed};


struct Judgement;
class UserController;
enum class BlockType : uint8_t {
    One = 1,
    Two = 2,
    Corner = 3,
    Square = 4,
    LeftL = 5,
    RightL = 6,
    Column = 7,
    Cross = 8,
};

static constexpr int BlockTypeVariantCount = 9;
static constexpr int BlockRotationCount = 4;

using ZipBlock = uint16_t;
using LineMask = uint16_t;
// 你知道的，一行只有10列
static constexpr LineMask FULL = 0b1'111'111'111;
static constexpr int BlockBound = 4;
static constexpr int LineBound = 18;
static constexpr int ExtraLine = 1;
static constexpr int ColumnBound = 10;
using BlockMask = std::array<LineMask, BlockBound>;
// 0 -> 全1的碰撞检测层
// 1 - 18 实际能放的地方
// 19 20 21 22 预留的为块放置的地方
using PlainMask = std::array<LineMask, LineBound + BlockBound + ExtraLine>;
class Block;
class BackMap;

// clang-format off
// #if __cplusplus == 201700L
// template <class... U>
// static constexpr ZipBlock do_zip(U... args) {
//     constexpr ZipBlock n = sizeof...(args);
//     static_assert(n <= BlockBound, "Too Much Arguements On DoZip!");
//     ZipBlock result = 0, i = 0;
//     ((result |= ((args & 0b1111) << (4 * (n - ++i)))), ...);
//     return result;
// }
// static constexpr ZipBlock PreProcessedBlocks[BlockTypeVariantCount][BlockRotationCount] = {
//     {0, 0, 0, 0},
//     // One
//     {1, 1, 1, 1},
//     // Two
//     {
//         do_zip(1, 1),
//         0b11,
//         do_zip(1, 1),
//         0b11,
//     },
//     // Corner
//     {
//         do_zip(0b01, 0b11),
//         do_zip(0b10, 0b11),
//         do_zip(0b11, 0b10),
//         do_zip(0b11, 0b01),
//     },
//     // Square
//     {
//         do_zip(0b11, 0b11),
//         do_zip(0b11, 0b11),
//         do_zip(0b11, 0b11),
//         do_zip(0b11, 0b11),
//     },
//     // LeftL
//     {
//         do_zip(0b10, 0b10, 0b11),
//         do_zip(0b111, 0b100),
//         do_zip(0b11, 0b01, 0b01),
//         do_zip(0b001, 0b111),
//     },
//     // RightL
//     {
//         do_zip(0b01, 0b01, 0b11),
//         do_zip(0b100, 0b111),
//         do_zip(0b11, 0b10, 0b10),
//         do_zip(0b111, 0b001),
//     },
//     // Column
//     {
//         do_zip(1, 1, 1, 1),
//         0b1111,
//         do_zip(1, 1, 1, 1),
//         0b1111,
//     },
//     // Cross
//     {
//         do_zip(0b010, 0b111, 0b010),
//         do_zip(0b010, 0b111, 0b010),
//         do_zip(0b010, 0b111, 0b010),
//         do_zip(0b010, 0b111, 0b010),
//     }
// };
// #else
static constexpr ZipBlock PreProcessedBlocks[BlockTypeVariantCount][BlockRotationCount] = {
    {0, 0, 0, 0},
    {1, 1, 1, 1},
    {17, 3, 17, 3},
    {19, 35, 50, 49},
    {51, 51, 51, 51},
    {547, 116, 785, 23},
    {275, 71, 802, 113},
    {4369, 15, 4369, 15},
    {626, 626, 626, 626}
};
// #endif
// clang-format on

constexpr static void do_unzip_on(BlockType tp, int rotation, BlockMask& mask) {
    ZipBlock blk = PreProcessedBlocks[(int)tp][rotation];
    for (int i = 0; i < BlockBound; ++i) {
        mask[i] = blk & 0b1111;
        blk >>= BlockBound;
    }
}

std::string _block_type_as_str(BlockType type) {
    static std::string _name_list[BlockTypeVariantCount] = {
        "Unknown", "One", "Two", "Corner", "Square", "LeftL", "RightL", "Column", "Cross",
    };
    return _name_list[(int)type];
}

static CPP23CONSTEXPR std::string readable(LineMask mask, char color = 'H') {
    std::string result(ColumnBound, '.');
    for (int i = ColumnBound - 1; i >= 0; --i) {
        if (mask & 1) {
            result[i] = color;
        }
        mask >>= 1;
    }
    return result;
}

static constexpr int hbit(LineMask mask) {
    return mask == 0 ? -1 : std::__lg(mask);
}

static constexpr int lbit(LineMask mask) {
    mask = mask & -mask;
    return mask == 0 ? 10 : std::__lg(mask);
}

static CPP23CONSTEXPR char as_color(uint8_t type) noexcept {
    if (type > BlockTypeVariantCount) {
        // 黑色背景
        return '.';
    }

    // 灰色（H） #777777 - 抬高层
    // 粉色（K） #FF69B4 - 单个方块
    // 青色（C） #00FFFF - 短条方块
    // 蓝色（B） #0000FF - 三角方块
    // 绿色（G） #00FF00 - 正宗方块
    // 橙色（O） #FFA500 - 左L方块
    // 黄色（Y） #FFFF00 - 右L方块
    // 红色（R） #FF0000 - 长条方块
    // 紫色（P） #800080 - 十字方块

    static constexpr char colors[9] = {'H', 'K', 'C', 'B', 'G', 'O', 'Y', 'R', 'P'};
    return colors[type];
}

class Block {
    friend Judgement;
    friend BackMap;
    friend UserController;
    BlockType btype;
    BlockMask mask;
    int rotation = 0;
    int x = 0;
    int y = 0;

    Block(BlockType type, int rotation = 0) : btype(type), rotation(rotation % BlockRotationCount) {
        (rotation += BlockRotationCount) %= BlockRotationCount;
        std::fill(mask.begin(), mask.end(), 0);
        do_unzip_on(type, rotation, mask);
    }
    void sent() const {
        std::cout << (int)btype << " " << rotation << " " << x << std::endl;
    }
public:
    char color() const {
        return as_color((uint8_t)btype);
    }

    BlockType type() const {
        return btype;
    }

    void rotate(int step = 1) {
        rotation = (rotation + step) % BlockRotationCount;
        do_unzip_on(btype, rotation, mask);
        x = 0;
    }

    int lbound() const {
        int res = -1;
        for (int i = 0; i < BlockBound; ++i) {
            res = std::max(res, hbit(mask[i]));
        }
        return res;
    }

    int rbound() const {
        int res = 10;
        for (int i = 0; i < BlockBound; ++i) {
            res = std::min(res, lbit(mask[i]));
        }
        return res;
    }

    /// Move the block horizontally by dx units.
    /// Returns true if the move was successful, false otherwise.
    bool move(int dx) {
        int left = lbound();
        int right = rbound();
        // [0,10)
        if (left + dx >= 10 || right + dx < 0)
            return false;
        x += dx;
        if (dx > 0) {
            for (int i = 0; i < BlockBound; ++i) {
                mask[i] <<= dx;
            }
        } else {
            dx = -dx;
            for (int i = 0; i < BlockBound; ++i) {
                mask[i] >>= dx;
            }
        }
        return true;
    }

    static Block make(BlockType type, int rotation = 0) {
        return Block(type, rotation);
    }

    class LineProxy {
        friend Block;
        LineMask const* ref = nullptr;

        LineProxy(Block const& block, int index) {
            ref = &block.mask[index];
        }

    public:
        uint8_t operator[](int i) const {
            return (*ref >> i) & 1;
        }
    };

    LineProxy operator[](int i) const {
        return LineProxy(*this, i);
    }
#if __cplusplus >= 202300L
    void describe() const {
        std::println("Block type: {}", _block_type_as_str(type));
        std::println("Mask:");
        for (int i = 3; i >= 0; --i) {
            std::println("{:010b}", mask[i]);
        }
        std::println("Rotation: {}", rotation);
        std::println("Position: ({}, {})", x, y);
    }
#endif
};

class BackMap {
    friend Block;
    friend UserController;
    friend Judgement;
    PlainMask plain;

    class FastDisplay {
        friend BackMap;
        static constexpr int Looping = LineBound + BlockBound;
        static CPP23CONSTEXPR CPP17FIXME std::string BasicLine = std::string(ColumnBound, '.');
        using DisplayInfo = std::array<std::string, Looping>;
        DisplayInfo detail;
        int offset = 0;

        std::string& operator[](int index) {
            return detail[(index + offset) % Looping];
        }

        std::string const& operator[](int index) const {
            return detail[(index + offset) % Looping];
        }
        void grow(LineMask mask) {
            offset = (offset - 1 + Looping) % Looping;
            operator[](0) = readable(mask);
        }
        void place(Block const& block, int h) {
            --h;
            char c = block.color();
            for (int i = 0; i < BlockBound; ++i) {
                auto line = block[i];
                for (int j = ColumnBound - 1; j >= 0; --j) {
                    if (line[j] != 0) {
                        operator[](h + i)[ColumnBound - 1 - j] = c;
                    }
                }
            }
        }
        public:
        FastDisplay() {
            detail.fill(BasicLine);
        }

        #if __cplusplus >= 202300L
        void describe() const {
            for (int h = LineBound + BlockBound; h > LineBound; --h) {
                std::println("{:02}:{}", h, operator[](h - 1));
            }
            std::println("--:{}", std::string(10, '-'));
            for (int h = LineBound; h > 0; --h) {
                std::println("{:02}:{}", h, operator[](h - 1));
            }
            std::println("00:{}", std::string(10, '-'));
        }
        #endif

        std::string compressed() const {
            std::string result;
            result.reserve((LineBound + BlockBound) * ColumnBound);
            for (int i = 0; i < LineBound + BlockBound; ++i) {
                result += operator[](i);
            }
            return LZ::compress(result);
        }
    } display;

    int score = 0;
    static constexpr int bonus[] = {0, 1, 3, 6, 10};
    bool alive = true;

    class LineProxy {
        friend BackMap;
        LineMask const* ref = nullptr;

        LineProxy(PlainMask const& plain, int index) {
            ref = &plain[index];
        }

        public:
        uint8_t operator[](int i) const {
            return (*ref >> i) & 1;
        }
    };

    int remove_detect() {
        int h = 1, removed = 0;
        for (int cur = 1; cur < LineBound + ExtraLine + BlockBound; ++cur) {
            if (plain[cur] == FULL) {
                plain[cur] = 0;
                ++removed;
            }

            if (plain[h] != 0) {
                ++h;
                continue;
            }

            plain[h] = plain[cur];
            plain[cur] = 0;

            display[h - 1] = display[cur - 1];
            display[cur - 1] = FastDisplay::BasicLine;

            if (plain[h] != 0) {
                ++h;
                continue;
            }
        }
        score += bonus[removed];
        return removed;
    }

    bool alive_detect() {
        int h = LineBound + ExtraLine;
        for (int i = 0; i < BlockBound; ++i) {
            alive = alive && (plain[h + i] == 0);
        }
        return alive;
    }
    void grow(LineMask mask) {
        mask &= FULL;
        assert(mask != FULL);
        if (!alive) {
            return;
        }

        for (int i = LineBound + BlockBound; i > 1; --i) {
            plain[i] = plain[i - 1];
        }
        plain[1] = mask;
        display.grow(mask);
        alive = alive_detect();
    }


public:
    LineProxy operator[](int i) const {
        return LineProxy(plain, i);
    }

    BackMap() {
        plain.fill(0);
        plain[0] = FULL;
    }
    int max_layer() const {
        for(int i = 22; ; --i) {
            if (plain[i] != 0) {
                return i;
            }
        }
    }
    int assume(Block const& block) {
        if (!alive) {
            return 0;
        }

        int h = LineBound + ExtraLine;
        // 检测碰撞
        for (; h > 0; --h) {
            bool hit = false;
            for (int i = 0; i < BlockBound; ++i) {
                hit = hit || ((plain[h + i] & block.mask[i]) != 0);
            }
            if (hit) {
                break;
            }
        }
        ++h;
        // 放置方块
        for (int i = 0; i < BlockBound; ++i) {
            plain[h + i] |= block.mask[i];
        }
        // 处理 可视化
        display.place(block, h);
        // 消除检测
        int removed = remove_detect();
        // 存活检测
        alive = alive_detect();
        return removed;
    }

    int current_score() const {
        return score;
    }

    std::pair<int, BackMap> preview(Block const& block) const {
        BackMap ret{*this};
        int removed = ret.assume(block);
        return {removed, ret};
    }

    bool is_alive() const {
        return alive;
    }

    std::string display_compressed() const {
        return display.compressed();
    }
#if __cplusplus >= 202300L
    void show_display() {
        display.describe();
    }
    void describe() const {
        std::println("Score: {}", score);
        for (int i = LineBound + BlockBound; i > LineBound; --i) {
            std::println("{}:{}", i, readable(plain[i]));
        }
        std::println("--:{}", std::string(10, '-'));
        for (int i = LineBound; i > 0; --i) {
            std::println("{:02}:{}", i, readable(plain[i]));
        }
        std::println(std::cerr,"00:{}", std::string(10, '-'));
    }
#endif
};

class BlockList {
    friend UserController;
    int n = 0;
    std::deque<BlockType> types;
    BlockList():types() {}
    void update() {
        std::cin >> n;
        int t;
        for (int i = 0; i < n; ++i) {
            std::cin >> t;
            types.emplace_back((BlockType)t);
        }
    }
    public:
    Block next_with(int rotation = 0) {
        BlockType t = types.front();
        types.pop_front();
        return Block::make(t, rotation);
    }

    BlockType peek(int i = 0) const {
        return types.at(i);
    }

    BlockType operator[](int i) const {
        return peek(i);
    }
};

// 交互流程
// 1. Judge -> User
// 回合 InitMap(n,...) 然后 TetrisList(m,...), 然后控制段 (0x{0/1/F}hh)
// 如果结束 （分数）
// 2. User -> Judge
// 每回合 Type Rotation Xmove
// 3. Judge -> Bot
// {
//   "command" : "request"
//   "content" : {"0" : "U..." }
//   "display" : "C/N playground.compressed_display()/score"
// }
// {
//   "command" : "finish"
//   "content" : {"0" : score }
//   "display" : "F score"
// }
// 4. Bot -> Judge
// { "0" : {"verdict": "OK", "raw": "T R X"} }
struct Schedule;
using Json = nlohmann::json;
enum class CommandType {
    Request,
    Finish,
};
class JWrapper {
    Json j;

public:
    JWrapper(CommandType type) {
        switch (type) {
            case CommandType::Request:
                j["command"] = "request";
                break;
            case CommandType::Finish:
                j["command"] = "finish";
                break;
            default:
                break;
        }
    }

    Json::reference display() {
        return j["display"];
    }
    struct ContentBuilder {
        std::deque<LineMask> up_floors = {};
        std::deque<BlockType> append_blocks = {};
        char uflag = 0;
        char rotate = 0;
        char dx = 0;
        std::string operator()() const {
            std::stringstream s;
            s << up_floors.size() << "\n";
            for (auto const & floor : up_floors) {
                s << floor << " ";
            }
            s << "\n";
            s << append_blocks.size() << "\n";
            for (auto const & block : append_blocks) {
                s << (int)block << " ";
            }
            s << "\n";
            int flag = uflag;
            flag <<= 4;
            flag |= rotate;
            flag <<= 4;
            flag |= dx;
            s << flag << "\n";
            return s.str();
        }
    };
    static ContentBuilder content_builder() {
        return {};
    }

    Json::reference player() {
        return j["content"]["0"];
    }

    void sent() {
        std::cout << j << std::endl;
    }

};
// {
/*
{"0":{"verdict":"OK","raw":"..."}}
*/
// }
class UserResponse {
#if 1
    Json j;
    public:
    UserResponse() {
        std::cin >> j;
        j = j["0"];
    }


    std::string verdict_detail() {
        return j["verdict"];
    }

    bool verdict() {
        return j["verdict"] == std::string("OK");
    }

    std::string raw() {
        return j["raw"];
    }
#else
    int t,r,x;
    public:
    UserResponse() {
        std::cin >> t >> r >> x;
    }

    bool verdict() {
        // return j["verdict"] == std::string("OK");
        return true;
    }

    std::string raw() {
        // return j["raw"];
        std::stringstream ss;
        ss << t << " " << r << " " << x << " ";
        return ss.str();
    }
#endif
};



struct Level {
    int i = 0;
};
class Normal {};
class InitWithLayers {};
class AutoLift {};
class Uncontrolable {};
class BlockSaver {};
constexpr char continue_flag = 'C';

// 关卡1 正常
// 关卡2 初始有若干层垫底
// 关卡3 每若干回合下方自动抬高一层
// 关卡4 每若干回合下一方块自动不受控掉落
// 关卡5 出现的方块非随机 比较难以处理
struct Judgement {
    std::mt19937_64 rng;
    std::deque<LineMask> _init = {};
    std::deque<BlockType> _next = {};
    std::string reason = "1 Normally Finish";
    // 当前要放的
    size_t to_place = 0;
    // 要预告的指针
    size_t to_prepare = 0;
    int _auto_up = 0;
    int _uncontrollable = 0;
    int _phas = 0;
    BackMap playground;

    Judgement(
        int auto_up = 0,
        int uncontrollable = 0,
        std::deque<LineMask> const & init = {},
        std::deque<BlockType> const & human_list = {},
        size_t preset_cnt = 200
    ) : rng(grng() ^ auto_up ^ uncontrollable),
        _auto_up(auto_up),
        _uncontrollable(uncontrollable),
        _init(init.begin(),init.end()),
        _next(human_list.begin(),human_list.end())
    {
        while (_next.size() < preset_cnt) {
            _next.push_back(gen_next_block());
        }
    }
    static Judgement make(Level t) {
        switch (t.i) {
            case 0:
            return preset(Normal{});
            break;
            case 1:
            return preset(InitWithLayers{});
            break;
            case 2:
            return preset(AutoLift{});
            break;
            case 3:
            return preset(Uncontrolable{});
            break;
            case 4:
            return preset(BlockSaver{});
            break;
            default:
            throw 0;
            break;
        }
    }
    static Judgement preset(Normal) {
        return Judgement(0,0,{},{},200);
    };
    static Judgement preset(InitWithLayers) {
        std::deque<LineMask> init;
        std::mt19937_64 rng {grng()};
        std::uniform_int_distribution<LineMask> rm(1,FULL - 1);
        constexpr size_t Layers = 6;
        while(init.size() < Layers) {
            LineMask mask = 0;
            do  {
                mask = rm(rng);
                std::cerr << mask << std::endl;
            } while (mask == 0 || mask == FULL);
            assert(mask != 0);
            assert(mask != FULL);
            init.push_back(mask);
        }
        return Judgement(0,0,init,{},200);
    };
    static Judgement preset(AutoLift) {
        int auto_lift_seed = grng() | 1;
        return Judgement(auto_lift_seed);
    };
    static Judgement preset(Uncontrolable) {
        int unctrl_seed = grng() | 1;
        return Judgement(0,unctrl_seed);
    };
    static Judgement preset(BlockSaver) {
        std::mt19937_64 rng {grng()};
        int auto_lift_seed = rng() | 1;
        int unctrl_seed = rng() | 1;
        std::deque<LineMask> init;
        std::uniform_int_distribution<LineMask> rm(1,FULL - 1);
        constexpr size_t Layers = 6;
        while(init.size() < Layers) {
            LineMask mask = 0;
            while (mask == 0 || mask == FULL) {
                mask = rm(rng);
            }
            init.push_back(mask);
        }

        std::deque<BlockType> human_list;
        std::uniform_int_distribution<int> oth_distr(1,7);
        int cross_cnt = 80;
        while (human_list.size() < cross_cnt) {
            human_list.push_back(BlockType::Cross);
        }
        while (human_list.size() < 200) {
            human_list.push_back((BlockType)oth_distr(rng));
        }
        std::shuffle(human_list.begin(), human_list.end(), rng);

        return Judgement(auto_lift_seed,unctrl_seed,init,human_list,200);
    };

    BlockType gen_next_block() {
        static double ps[] = {
            0,
            0.16,
            0.32,
            0.47,
            0.61,
            0.74,
            0.86,
            0.94,
            1
        };
        std::uniform_real_distribution<double> urd(0,1);
        double p = urd(rng);
        return (BlockType)(std::lower_bound(ps,ps + 8,p) - ps);
    }

    LineMask gen_next_line() {
        LineMask mask = 0;
        std::uniform_int_distribution<LineMask> rm(1,FULL - 1);
        while (mask == 0 || mask == FULL) {
            mask = rm(rng);
        }
        return mask;
    }
    int t = -1,r = -1,x = -1;
    std::string raw_input = "";
    void jinput() {
        if (_phas == -1) {
            return;
        }
        UserResponse u; 
        if (!u.verdict()) {
            std::stringstream ss;
            ss << "0 " << u.verdict_detail();
            reason = ss.str();
            to_place = _next.size();
            return;
        }
        raw_input = u.raw();
        std::stringstream s {u.raw()};

        s >> t >> r >> x;
        BlockType real_t = _next[to_place];

        if ((BlockType)t != real_t) {
            std::stringstream ss;
            ss << "2 " << _block_type_as_str(real_t) << "  " << _block_type_as_str((BlockType)t);
            reason = ss.str();
            to_place = _next.size();
            return;
        }

        Block b = Block::make(real_t,r);
        if (!b.move(x)) {
            std::stringstream ss;
            ss << "3 " << _block_type_as_str((BlockType)t) << " " << r << " " << x;
            reason = ss.str();
            to_place = _next.size();
            return;
        }
        playground.assume(b);
        ++to_place;
        --_phas;
        if (!playground.is_alive()) {
            std::stringstream ss;
            ss << "4 " << _block_type_as_str(b.type()) << " " << b.rotation << " " << b.x;
            reason = ss.str();
            to_place = _next.size();
        }
    }
    JWrapper::ContentBuilder builder;
    void joutput() {
        // N
        // Lift...
        // M
        // Block...
        // Control
        JWrapper j(CommandType::Request);
        builder = JWrapper::content_builder();
        // Lift?
        if (!_init.empty()) {
            builder.up_floors.swap(_init);
        } else if (_auto_up != 0) {
            std::bernoulli_distribution pd(0.07);
            if (pd(rng)) {
                builder.up_floors.push_back(gen_next_line());            
            }
        }

        for(auto const &L:builder.up_floors) {
            playground.grow(L);
        }

        // Append?
        // cursor is to_prepare
        do {
            if (to_prepare == _next.size()) {
                break;
            }
            std::uniform_real_distribution<double> pd(0,1); 
            double pp = 1./ (double)(_phas + 1);
            double pcheck = pd(rng);
            if (pcheck > pp) {
                break;
            }
            std::binomial_distribution<> nd(10,pp);
            int many = nd(rng);
            many += (many == 0);

            int st = to_prepare;
            to_prepare += many;
            int ed = std::min(to_prepare,_next.size());
            _phas += many;
            for(int i = st; i < ed; ++i) {
                builder.append_blocks.push_back(_next[i]);
            }
        } while(0);

        // Ctrl?
        do {
            if (_uncontrollable == 0 || to_place >= to_prepare) {
                break;
            }
            std::uniform_real_distribution<double> pd(0,1);
            double pcheck = pd(rng);
            if (pcheck > 0.08) {
                break;
            }
            builder.uflag = 1;
            std::uniform_int_distribution<> rd(0,3);
            builder.rotate = rd(rng);
            Block curblock = Block::make(_next[to_place],builder.rotate);
            std::uniform_int_distribution<> xd(0,9 - curblock.lbound());
            builder.dx = xd(rng);
            curblock.move(builder.dx);
            playground.assume(curblock);
            ++to_place;
            --_phas;
        } while(0);

        if (!playground.is_alive()) {
            builder.uflag = 0xF;
            builder.rotate = 0xF;
            builder.dx = 0xF;
            to_place = _next.size();
            _phas = -1;
            reason = "5 Unctrl Or UpLift";
        }

        if (_phas == -1) {
            return;
        }

        j.player() = builder();
        // j.display() = debug_with_display('C');
        j.display() = display_info_gen('C');
        j.sent();
    }


    std::string display_info_gen(char flag) const {
        std::stringstream ss;
        ss << flag << " " << playground.score << " " << playground.display_compressed();
        if (flag != 'C') {
            ss << " " << reason;        
        } 
        // ss << "||" << raw_input << " <" << (int)builder.uflag; 
        // ss << "> Size: " << (builder.append_blocks.size()) << " {";
        // for(auto ab: builder.append_blocks) {
        //     ss << (int)(ab) << " ";
        // }
        // ss << "}";
        return ss.str();
    }

    std::string debug_with_display(char flag) const {
        auto const & b = builder;
        std::stringstream ss;
        ss << "INL: " << raw_input << "|!|";
        ss << "Flag: " << flag << " | ";
        ss << "UpF: " << (b.up_floors.size()) << " | ";
        for(auto L: b.up_floors) {
            ss << L << " ";
        }
        ss << "| ApB: " << (b.append_blocks.size()) << " | ";
        for(auto ab: b.append_blocks) {
            ss << (int)(ab) << " ";
        }
        ss << "{" << b() << "}";
        if (flag != 'C') {
            ss << "| Why! >>" << reason;        
        }
        return ss.str();  
    }

    void jresult() {
        if (reason != "" && reason[0] == '0') {
            reason = "";
            return;
        }
        JWrapper j(CommandType::Request);
        if (_phas != -1) {
            auto builder = JWrapper::content_builder();        
        }
        builder.uflag = 0xF;
        j.player() = builder();
        // j.display() = debug_with_display('N');
        j.display() = display_info_gen('N');
        j.sent();
        reason = "";
    }

    void jloop() {
        while (to_place != _next.size()) {
            joutput();                     
            jinput();
        }
        jresult();
    }
};

void judge() {
    int finish_score = 0;
    for(int i = 0;i < 5; ++i){
        Judgement judgement = Judgement::make(Level{i});
        judgement.jloop();
        finish_score += judgement.playground.current_score();
        // 新一轮需要 0 0 0 
        UserResponse u;
        if (!u.verdict()) {
            break;
        }
    }
    JWrapper finish(CommandType::Finish);
    finish.player() = finish_score;
    finish.display() = std::string("F ") + std::to_string(finish_score);
    finish.sent();
}

int main() {
    try {
        judge();
    } catch (...) {
        JWrapper finish(CommandType::Finish);
        finish.player() = 0;
        finish.display() = std::string("ErrCatch");
        finish.sent();
    }
}

[bkmashiro]

可以加一些bot/裁判意外退出的逻辑.