ICPC国内予選2025（Chofu Mai）

#include <iostream>
#include <vector>
#include <cstdlib>
#include <source_location>

template <typename T>
class sv : public std::vector<T> {
    static_assert(!std::is_same_v<T, bool>,
        "sv<bool>は動きません（ごめん）");

public:
    using std::vector<T>::vector;
    explicit sv(const std::vector<T>& v) : std::vector<T>(v) {}
    explicit sv(std::vector<T>&& v) : std::vector<T>(std::move(v)) {}

#ifdef CHOFUMAI
    T& operator[](size_t index) {
        if (index >= this->size()) {
            handle_bounds_error(index, std::source_location::current());
        }
        return std::vector<T>::operator[](index);
    }
    const T& operator[](size_t index) const {
        if (index >= this->size()) {
            handle_bounds_error(index, std::source_location::current());
        }
        return std::vector<T>::operator[](index);
    }
    T& operator()(size_t index, const std::source_location location = std::source_location::current()) {
        if (this->size() <= index) handle_bounds_error(index, location);
        return std::vector<T>::operator[](index);
    }
    const T& operator()(size_t index, const std::source_location location = std::source_location::current()) const {
        if (this->size() <= index) handle_bounds_error(index, location);
        return std::vector<T>::operator[](index);
    }
    
    T& front(const std::source_location location = std::source_location::current()) {
        if (this->empty()) handle_empty_error("front", location);
        return std::vector<T>::front();
    }
    const T& front(const std::source_location location = std::source_location::current()) const {
        if (this->empty()) handle_empty_error("front", location);
        return std::vector<T>::front();
    }
    T& back(const std::source_location location = std::source_location::current()) {
        if (this->empty()) handle_empty_error("back", location);
        return std::vector<T>::back();
    }
    const T& back(const std::source_location location = std::source_location::current()) const {
        if (this->empty()) handle_empty_error("back", location);
        return std::vector<T>::back();
    }

    [[noreturn]] void handle_bounds_error(size_t index, const std::source_location& location) const {
        std::cerr << "【範囲外アクセスエラー】\n"
                  << "  ファイル: " << location.file_name() << "\n"
                  << "  行: " << location.line() << ", " << location.column() << "文字目\n"
                  << "  関数: " << location.function_name() << "\n"
                  << "  配列サイズ: " << this->size() << "\n"
                  << "  アクセス添字: " << index << "\n";
        std::exit(1);
    }
    
    [[noreturn]] void handle_empty_error(const char* operation, const std::source_location& location) const {
        std::cerr << "【空配列アクセスエラー】\n"
                  << "  操作: " << operation << "()\n"
                  << "  ファイル: " << location.file_name() << "\n"
                  << "  行: " << location.line() << ", " << location.column() << "文字目\n"
                  << "  関数: " << location.function_name() << "\n";
        std::exit(1);
    }
#else
    T& operator[](size_t index) {
        if (index >= this->size()) {
            handle_bounds_error(index);
        }
        return std::vector<T>::operator[](index);
    }
    const T& operator[](size_t index) const {
        if (index >= this->size()) {
            handle_bounds_error(index);
        }
        return std::vector<T>::operator[](index);
    }
    T& operator()(size_t index) {
        if (this->size() <= index) handle_bounds_error(index);
        return std::vector<T>::operator[](index);
    }
    const T& operator()(size_t index) const {
        if (this->size() <= index) handle_bounds_error(index);
        return std::vector<T>::operator[](index);
    }

    T& front() {
        if (this->empty()) handle_empty_error("front");
        return std::vector<T>::front();
    }
    const T& front() const {
        if (this->empty()) handle_empty_error("front");
        return std::vector<T>::front();
    }
    T& back() {
        if (this->empty()) handle_empty_error("back");
        return std::vector<T>::back();
    }
    const T& back() const {
        if (this->empty()) handle_empty_error("back");
        return std::vector<T>::back();
    }

    [[noreturn]] void handle_bounds_error(size_t) const {
        std::exit(1);
    }
    [[noreturn]] void handle_empty_error(const char*) const {
        std::exit(1);
    }
#endif

    std::vector<T> copy() const {
        return *this;
    }
};

#include <iostream>
using namespace std;

int main () {
    sv<int> v(5, 10);
    vector<int> x(10);

    cout << v[0] << v[1] << endl;
    //v[-1];
    v[5];

    sv<int> y(move(x));
    sv<int> p, q;
    swap(p, q);

    auto vv = v.copy();
    cout << vv[0] << endl;
}

#include<bits/stdc++.h>
using namespace std;

#ifdef CHOFUMAI
#include <cpp-dump.hpp>
#define dump(...) cpp_dump(__VA_ARGS__)
#define PARTITION() cerr << "====================" << endl
#define START() \
    std::cerr << "\n╔══════════════════════════════════════╗\n" \
              <<   "║             START PROGRAM            ║\n" \
              <<   "╚══════════════════════════════════════╝\n";

#define END() \
    std::cerr << "\n╔══════════════════════════════════════╗\n" \
              <<   "║              END PROGRAM             ║\n" \
              <<   "╚══════════════════════════════════════╝\n";
#define SLEEP() sleep(1)
#else
#define dump(...)
#define PARTITION()
#define START()
#define END()
#define SLEEP()
#endif

using ll = long long;
using ull = unsigned long long;
using ld = long double;

using LL = long long; using ULL = unsigned long long;
using VI = vector<int>; using VVI = vector<VI>; using VVVI = vector<VVI>;
using VL = vector<LL>; using VVL = vector<VL>; using VVVL = vector<VVL>;
using VB = vector<bool>; using VVB = vector<VB>; using VVVB = vector<VVB>;
using VD = vector<double>; using VVD = vector<VD>; using VVVD = vector<VVD>;
using VC = vector<char>; using VS = vector<string>; using VVC = vector<VC>;
using PII = pair<int,int>; using PLL = pair<LL,LL>; using PDD = pair<double,double>; using PIL = pair<int,LL>;
using MII = map<int,int>; using MLL = map<LL,LL>;
using SI = set<int>; using SL = set<LL>;
using MSI = multiset<int>; using MSL = multiset<LL>;
template<class T> using MAXPQ = priority_queue<T>;
template<class T> using MINPQ = priority_queue< T, vector<T>, greater<T> >;

constexpr ll MOD = 1000000007;
constexpr ll MOD2 = 998244353;
constexpr ll INF = 1LL << 60;
constexpr int iINF = 1 << 30;
constexpr double PI = 3.14159265358979323846;

#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)

// repマクロ（REPではなく...笑）
#define rep(i, n) FOR(i, 0, n)

#define EACH(e, v) for(auto &e : v)
#define RITR(it, v) for(auto it = (v).rbegin(); it != (v).rend(); ++it)
#define ALL(v) v.begin(),v.end()

vector<ll> x8={1,1,1,0,0,-1,-1,-1},y8={1,0,-1,1,-1,1,0,-1};
int dx4[4]={1,-1,0,0}, dy4[4]={0,0,1,-1};

namespace libs {
    // ライブラリペタリゾーン
} // namespace libs

using namespace libs;

bool solver () {
    dump("your solution here...");
    return false;
}

int main(){
    cin.tie(0);
    ios_base::sync_with_stdio(0);

    // 浮動小数点のアレ
    cout << fixed << setprecision(20);

    SLEEP();
    START();

    int testcase_id = 1;
    while (true) {
        PARTITION();
        dump(testcase_id);
        bool next = solver();
        testcase_id++;

        if (!next) {
            break;
        }
    }

    END();
}