#include <cassert>
#include <iostream>
#include <vector>

namespace {

struct range_t {
    int start;
    int end;

    range_t(int start, int end)
        : start(start)
        , end(end)
    {
    }

    bool has(int x) const { return x > start && x < end; }

    bool operator>(const range_t& other) const { return start > other.start; }

    bool operator==(const range_t& other) const
    {
        return start == other.start && end == other.end;
    }
};

bool overlaps(const range_t& a, const range_t& b)
{
    return a == b || a.has(b.start) || a.has(b.end) || b.has(a.start) || b.has(a.end);
}

} // namespace

class MyCalendar {
    std::vector<range_t> entries;

public:
    MyCalendar() = default;

    bool book(int start, int end)
    {
        entries.emplace_back(start, end);

        auto it = entries.end();
        it--;

        for (int i = entries.size() - 1; i > 0 && entries[i - 1] > entries[i];
             i--, it--) {
            if (overlaps(entries[i], entries[i - 1])) {
                entries.erase(it);
                return false;
            }

            std::swap(entries[i], entries[i - 1]);
        }

        if (it > entries.begin() && overlaps(*it, *(it - 1))) {
            entries.erase(it);
            return false;
        }

        return true;
    }
};

/**
 * Your MyCalendar object will be instantiated and called as such:
 * MyCalendar* obj = new MyCalendar();
 * bool param_1 = obj->book(start,end);
 */

static void test_case_1()
{
    std::cout << "=== TEST CASE 1 ===\n";

    std::vector<range_t> entries { { 47, 50 }, { 33, 41 }, { 39, 45 }, { 33, 42 },
        { 25, 32 }, { 26, 35 }, { 19, 25 }, { 3, 8 },
        { 8, 13 }, { 18, 27 } };
    std::vector<bool> expected { true, true, false, false, true,
        false, true, true, true, false };

    MyCalendar c;
    for (auto i = 0; i < entries.size(); i++) {
        std::cout << "[TEST] Entry #" << i << "\n";

        auto [start, end] = entries[i];
        assert(c.book(start, end) == expected[i]);

        std::cout << "[PASS]\n\n";
    }
}

static void test_case_2()
{
    std::cout << "=== TEST CASE 2 ===\n";

    std::vector<range_t> entries { { 37, 50 }, { 33, 50 }, { 4, 17 }, { 35, 48 }, { 8, 25 } };
    std::vector<bool> expected { true, false, true, false, false };

    MyCalendar c;
    for (auto i = 0; i < entries.size(); i++) {
        std::cout << "[TEST] Entry #" << i << "\n";

        auto [start, end] = entries[i];
        assert(c.book(start, end) == expected[i]);

        std::cout << "[PASS]\n\n";
    }
}

static void test_case_3()
{
    std::cout << "=== TEST CASE 3 ===\n";

    std::vector<range_t> entries {
        { 20, 29 }, { 13, 22 }, { 44, 50 }, { 1, 7 }, { 2, 10 }, { 14, 20 },
        { 19, 25 }, { 36, 42 }, { 45, 50 }, { 47, 50 }, { 39, 45 }, { 44, 50 },
        { 16, 25 }, { 45, 50 }, { 45, 50 }, { 12, 20 }, { 21, 29 }, { 11, 20 },
        { 12, 17 }, { 34, 40 }, { 10, 18 }, { 38, 44 }, { 23, 32 }, { 38, 44 },
        { 15, 20 }, { 27, 33 }, { 34, 42 }, { 44, 50 }, { 35, 40 }, { 24, 31 }
    };
    std::vector<bool> expected {
        true, false, true, true, false, true, false, true, false, false,
        false, false, false, false, false, false, false, false, false, false,
        false, false, false, false, false, false, false, false, false, false
    };

    MyCalendar c;
    for (auto i = 0; i < entries.size(); i++) {
        std::cout << "[TEST] Entry #" << i << "\n";

        auto [start, end] = entries[i];
        assert(c.book(start, end) == expected[i]);

        std::cout << "[PASS]\n\n";
    }
}

int main()
{
    MyCalendar c;
    assert(c.book(10, 20));
    assert(!c.book(15, 25));
    assert(c.book(20, 30));

    test_case_1();
    test_case_2();
    test_case_3();

    return 0;
}