#include <cstddef>
#include <utility>

template<typename T>
struct UniquePtr {
    T * a;

    UniquePtr() {
        a = nullptr;
    }

    UniquePtr(T * b) {
        a = b;
    }

    void Delete() {
        delete a;
    }

    UniquePtr(UniquePtr<T> && b) {
        a = b.a;
        b.a = nullptr;
    }

    UniquePtr& operator =(UniquePtr && b) {
        this->~UniquePtr();
        a = b.a;
        b.a = nullptr;
        return *this;
    }

    T& operator*() {
        return *a;
    }

    T const & operator*() const {
        return *a;
    }

    T* operator->() const {
        return a;
    }

    UniquePtr& operator =(std::nullptr_t) {
        reset(nullptr);
        return *this;
    }

    UniquePtr (UniquePtr<T> & a) = delete;

    ~UniquePtr() {
        delete a;
        a = nullptr;
    }

    T * release() {
        T * copy = a;
        a = nullptr;
        return copy;
    }

    void reset(T * ptr) {
        *this = std::move(UniquePtr<T>(ptr));
    }

    void swap(UniquePtr& other) {
        std::swap(a, other.a);
    }

    T * get() const {
        return a;
    }

    explicit operator bool() const {
        return a;
    }

    UniquePtr& operator =(const UniquePtr&) = delete;
};