template <typename T>
class SharedPtr {
private:
    T* data;
    int* count;

public:
    SharedPtr() : data(nullptr), count(new int(0)) {
    }

    SharedPtr(T* ptr) : data(ptr), count(new int(1)) {
    }

    SharedPtr(const SharedPtr& other)
        : data(other.data), count(other.count) {
        (*count)++;
    }

    SharedPtr(SharedPtr&& other)
        : data(other.data), count(other.count) {
    }

    SharedPtr& operator=(const SharedPtr& other) {
        if (data != other.data) {
            (*count)--;
            if (*count == 0) {
                delete data;
                delete count;
            }
            data = other.data;
            count = other.count;
            (*count)++;
        }
        return *this;
    }

    SharedPtr& operator=(T* other) {
        if (data != other) {
            (*count)--;
            if (*count == 0) {
                delete data;
                delete count;
            }
            data = other.data;
            count = new int(0);
            (*count)++;
        }
        return *this;
    }

    SharedPtr& operator=(SharedPtr&& other) {
        if (data != other.data) {
            (*count)--;
            if (*count == 0) {
                delete data;
                delete count;
            }
            data = other.data;
            count = other.count;
            other.data = nullptr;
            other.count = nullptr;
        }
        return *this;
    }

    T* get() const noexcept {
        return data;
    }

    ~SharedPtr() {
        (*count)--;
        if ((*count) == 0) {
            delete count;
            delete data;
        }
    }

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

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

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

    void reset(T* ptr) {
        (*count--);
        if ((*count) == 0) {
            delete data;
            delete count;
        }
        count = new int(1);
        data = ptr;
    }

    void swap(SharedPtr& other) {
        std::swap(data, other.data);
        std::swap(count, other.count);
    }

    explicit operator bool() const {
        return data != nullptr;
    }
};