#include <cassert>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <map>
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
#include <numeric>
#include <chrono>
#include <type_traits>
#include <sstream>
#include <unordered_map>
#include <stdexcept>
#include <optional>
#include <stack>
#include <iomanip>
#include <cstdlib>
#include <thread>
#include <random>
#include <fstream>
#include <algorithm>
#include <deque>
#include <cstddef>  // cstddef необходим для использования std::byte
#include <cstdint>  // cstdint необходим для использования uint32_t и int64_t
#include <ctime>
#include <new>
#include <cassert>
#include <iterator>
#include <string>
#include <utility>
#include <list>
#include <string_view>
#include <forward_list>
#include <initializer_list>
template <typename Type>
class ArrayPtr {
public:
    ArrayPtr() = default;
    explicit ArrayPtr(size_t size) {
        if (!size){
            raw_ptr_ = nullptr;
            return;
        }
        try{
            raw_ptr_ = new Type[size]();
        }
        catch(...) {
            raw_ptr_ = nullptr;
            throw;
        }
    }
    ArrayPtr(ArrayPtr&& other) noexcept
        : raw_ptr_(other.Release())
    {}
    explicit ArrayPtr(Type* raw_ptr) noexcept {
        raw_ptr_ = raw_ptr;
    }
    ArrayPtr(const ArrayPtr&) = delete;
    ~ArrayPtr() {
        delete[] raw_ptr_;
    }
    ArrayPtr& operator=(const ArrayPtr& rhs) = delete;
    ArrayPtr& operator=(ArrayPtr&& rhs) {
        if (raw_ptr_ != nullptr) {
            delete[] raw_ptr_;
        }
        raw_ptr_ = std::exchange(rhs.raw_ptr_, nullptr);
        return *this;
    }
    [[nodiscard]] Type* Release() noexcept {
        Type *t = raw_ptr_;
        raw_ptr_ = nullptr;
        return t;
    }
    Type& operator[](size_t index) noexcept {
        return raw_ptr_[index];
    }
    const Type& operator[](size_t index) const noexcept {
        return raw_ptr_[index];
    }
    explicit operator bool() const {
        return raw_ptr_ != nullptr;
    }
    Type* Get() const noexcept {
        return raw_ptr_;
    }
    void swap(ArrayPtr& other) noexcept {
        // Реализуйте метод самостоятельно
        std::swap(raw_ptr_, other.raw_ptr_);
    }
private:
    Type* raw_ptr_ = nullptr;
    size_t size_;
};