#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <memory>

template<class T>
struct RawMemory {
    T* data = nullptr;
    size_t cp = 0;

    RawMemory(size_t n = 0) {
        data = static_cast<T*>(::operator new(n * sizeof(T)));
        cp = n;
    }
    RawMemory(const RawMemory&) = delete;
    RawMemory(const RawMemory&& other) {
        swap(other);
    }
    ~RawMemory() {
        ::operator delete(data);
    }

    void swap(RawMemory& other) noexcept {
        std::swap(data, other.data);
        std::swap(cp, other.cp);
    }
};

template<class T>
class Vector {
private:
    size_t sz = 0;
    RawMemory<T> raw;

public:
    Vector(size_t size = 0) : sz(size), raw(size) {
        std::uninitialized_default_construct_n(raw.data, sz);
    }
    Vector(const Vector& other) : sz(other.sz), raw(other.sz) {
        std::uninitialized_copy_n(other.raw.data, sz, raw.data);
    }
    Vector(Vector&& other) noexcept {
        swap(other);
    }
    ~Vector() {
        for (size_t i = 0; i < sz; ++i)
            raw.data[i].~T();
    }

    size_t size() const {
        return sz;
    }

    size_t capacity() const {
        return raw.cp;
    }

    void swap(Vector& other) {
        std::swap(other.sz, sz);
        raw.swap(other.raw);
    }

    T* begin() const {
        return raw.data;
    }

    T* end() const {
        return raw.data + sz;
    }

    Vector& operator=(Vector&& other) {
        swap(other);
        return *this;
    }

    Vector& operator=(const Vector& other) { // нужно исправить?
        auto tmp(other);
        swap(tmp);
        return *this;
    }

    void reserve(size_t cp) {
        if (raw.cp < cp) {
            try {
                size_t i = 0;
                RawMemory<T> tmp(cp);

                try {
                    for (; i < sz; ++i)
                        new (tmp.data + i) T(raw.data[i]);
                    for (size_t j = 0; j < sz; ++j)
                        raw.data[j].~T();
                    raw.swap(tmp);
                }
                catch (...) {
                    for (size_t j = 0; j < i; ++j)
                        raw.data[j].~T();
                    throw;
                }
            }
            catch (...) {
                throw;
            }
        }
    }

    void resize(size_t new_sz) {
        if (new_sz >= raw.cp) {
            try {
                size_t i = 0;
                RawMemory<T> tmp(new_sz);

                try {
                    for (; i < sz; ++i)
                        new (tmp.data + i) T(raw.data[i]);
                    for (size_t i = sz; i < new_sz; ++i)
                        new (tmp.data + i) T();
                    for (size_t i = new_sz; i < sz; ++i)
                        raw.data[i].~T();
                    for (size_t j = 0; j < sz; ++j)
                        raw.data[j].~T();
                    raw.swap(tmp);
                }
                catch (...) {
                    for (size_t j = 0; j < i; ++j)
                        raw.data[j].~T();
                    throw;
                }
            }
            catch (...) {
                throw;
            }
        }
        else {
            for (size_t i = sz; i < new_sz; ++i)
                new (raw.data + i) T();
            for (size_t i = new_sz; i < sz; ++i)
                raw.data[i].~T();
        }

        sz = new_sz;
    }

    void pop_back() {
        raw.data[--sz].~T();
    }

    void push_back(const T& elem) {
        if (raw.cp == sz)
            reserve(std::max<size_t>(1, 2 * sz));
        new (raw.data + sz++) T(elem);
    }

    void push_back(T&& elem) {
        if (raw.cp == sz)
            reserve(std::max<size_t>(1, 2 * sz));
        new (raw.data + sz++) T(std::move(elem));
    }

    T operator[](size_t i) const {
        return raw.data[i];
    }

    T& operator[](size_t i) {
        return raw.data[i];
    }

    void clear() {
        Vector<T> tmp;
        swap(tmp);
    }
};