#include <atomic>
#include <type_traits>
#ifndef _POWELLCS440
#include <cassert>
#include <concepts>
#include <iostream>

#define todo(msg)                                                              \
  std::cerr << msg << std::endl;                                               \
  assert(false);

namespace cs440 {
using counter = std::atomic<std::size_t>;
template <typename T> struct Base {
  template <typename U> friend struct Base;

  T *ptr;
  Base(T *ptr) : ptr{ptr} {}
  template <typename U> Base(Base<U> const &ptr) : ptr{ptr.ptr} {}
  template <typename U> operator U() { return U(*this); }

public:
  virtual T &operator*() { return *ptr; }
  virtual T *operator->() { return ptr; }
  virtual ~Base() = default;
};
template <typename T, typename U> class Derived : public Base<T> {
  static_assert(std::is_base_of_v<T, U>);
  U *ptr;

public:
  Derived(Base<T> b) : Derived{*dynamic_cast<Derived<T, U> *>(&b)} {}
  U &operator*() { return *ptr; }
  U *operator->() { return ptr; }
  virtual ~Derived() { delete this->ptr; }
};
template <typename T> class SharedPtr {
public:
  Base<T> *ptr;
  counter *count;

  // problem?
  SharedPtr() : ptr{nullptr}, count{new std::atomic<std::size_t>{0}} {}
  template <typename U>
  explicit SharedPtr(U *ptr)
      : ptr{static_cast<Base<T> *>(new Derived<T, U>{ptr})},
        count{new std::atomic<std::size_t>{ptr ? 1 : 0}} {}
  SharedPtr(const SharedPtr &p) : ptr{p.ptr} {}
  template <typename U>
  SharedPtr(const SharedPtr<U> &p) : ptr(Base<T>(*p.ptr)), count{p.count} {
    (*count)++;
  }
  SharedPtr(SharedPtr &&p) : ptr{p.ptr} { p.ptr = nullptr; }
  template <typename U> SharedPtr(SharedPtr<U> &&p) : ptr{p.ptr} {
    p.ptr = nullptr;
  }
  SharedPtr &operator=(const SharedPtr &ptr) {
    this->ptr = ptr.ptr;
    (*count)++;
    return *this;
  }
  template <typename U> SharedPtr<T> &operator=(const SharedPtr<U> &ptr) {
    this->ptr = new Derived<T, U>{Base<T>(ptr.ptr)};
    return *this;
  }
  SharedPtr &operator=(SharedPtr &&p) {
    ptr = p.ptr;
    p.ptr = nullptr;
  }
  template <typename U> SharedPtr &operator=(SharedPtr<U> &&p) {
    ptr = p.ptr;
    p.ptr = nullptr;
  }
  ~SharedPtr() {
    if (this->count == nullptr) {
      if (this->ptr != nullptr) {
        delete this->ptr;
      }
      return;
    }
    if (--(*this->count) == 0) {
      delete this->count;
      delete this->ptr;
    }
  }
  void reset() { this->ptr = nullptr; }
  template <typename U> void reset(U *p) { this->ptr = new Derived<U>{p}; }
  T *get() const { return this->ptr->ptr; }
  T &operator*() const { return this->ptr->operator*(); }
  T *operator->() const { return this->ptr->operator->(); }
  explicit operator bool() const { return this->ptr->ptr != nullptr; }
  template <typename U>
  friend SharedPtr<U> static_pointer_cast(const SharedPtr<T> &sp) {
    todo("");
  }
  template <typename U>
  friend SharedPtr<U> dynamic_pointer_cast(const SharedPtr<T> &sp) {
    todo("");
  }
};
template <typename T1, typename T2>
bool operator==(const SharedPtr<T1> &lhs, const SharedPtr<T2> &rhs) {
  return lhs.get() == rhs.get();
}
template <typename T>
bool operator==(const SharedPtr<T> &lhs, std::nullptr_t rhs) {

  return lhs.get() == rhs;
}
template <typename T>
bool operator==(std::nullptr_t lhs, const SharedPtr<T> &rhs) {
  return lhs == rhs.get();
}
template <typename T1, typename T2>
bool operator!=(const SharedPtr<T1> &lhs, const SharedPtr<T2> &rhs) {
  return !(lhs == rhs);
}
template <typename T>
bool operator!=(const SharedPtr<T> &lhs, std::nullptr_t rhs) {
  return !(lhs == rhs);
}
template <typename T>
bool operator!=(std::nullptr_t lhs, const SharedPtr<T> &rhs) {
  return !(lhs == rhs);
}
} // namespace cs440
#endif