Compiler Explorer

Source code

#define FMT_HEADER_ONLY

#include <algorithm>
#include <tuple>
#include <memory>
#include <utility>
#include <concepts>
#include <type_traits>
#include <source_location>
#include <functional>
#include <cstddef>
#include <cmath>
#include <cstdint>
#include <fmt/core.h>
#include <fmt/format.h>
#include <optional>
#undef NAN
#undef INFINITY

namespace sus {
namespace cmp {}

}

namespace sus::cmp {
template <class T, class U = T>
concept Eq = requires(const std::remove_reference_t<T>& lhs,
 const std::remove_reference_t& rhs) {
 { lhs == rhs } -> std::same_as<bool>;
 { lhs != rhs } -> std::same_as<bool>;
};

}

namespace sus {

namespace assertions {}
}

namespace sus::assertions {

namespace __private {
void print_panic_message(const char& msg,
                         const std::source_location& location) noexcept;
void print_panic_message(std::string_view msg,
                         const std::source_location& location) noexcept;
void print_panic_location(const std::source_location& location) noexcept;
}

[[noreturn]] __attribute__((not_tail_called)) __attribute__((nomerge)) inline void panic(
    const std::source_location location =
        std::source_location::current()) noexcept {

__private::print_panic_location(location);

abort();

}

[[noreturn]] __attribute__((not_tail_called)) __attribute__((nomerge)) inline void panic_with_message(
    const char* msg, const std::source_location location =
                         std::source_location::current()) noexcept {

__private::print_panic_message(msg, location);

abort();

}

[[noreturn]] __attribute__((not_tail_called)) __attribute__((nomerge)) inline void panic_with_message(
    std::string_view msg, const std::source_location location =
                              std::source_location::current()) noexcept {

__private::print_panic_message(msg, location);

abort();

}

[[noreturn]] __attribute__((not_tail_called)) __attribute__((nomerge)) inline void panic_with_message(
    const std::string& msg, const std::source_location location =
                                std::source_location::current()) noexcept {

__private::print_panic_message(msg.c_str(), location);

abort();

}

namespace sus {
using ::sus::assertions::panic;
using ::sus::assertions::panic_with_message;
}

namespace sus::assertions {

constexpr inline __attribute__((always_inline)) void check(
    bool cond,
    const std::source_location location = std::source_location::current()) {
  if (!cond) [[unlikely]]
    ::sus::panic(location);
}

constexpr inline __attribute__((always_inline)) void check_with_message(
    bool cond, const char* msg,
    const std::source_location location = std::source_location::current()) {
  if (!cond) [[unlikely]]
    ::sus::panic_with_message(msg, location);
}

constexpr inline __attribute__((always_inline)) void check_with_message(
    bool cond, std::string_view msg,
    const std::source_location location = std::source_location::current()) {
  if (!cond) [[unlikely]]
    ::sus::panic_with_message(msg, location);
}

constexpr inline __attribute__((always_inline)) void check_with_message(
    bool cond, const std::string& msg,
    const std::source_location location = std::source_location::current()) {
  if (!cond) [[unlikely]]
    ::sus::panic_with_message(msg, location);
}

}

namespace sus {
using ::sus::assertions::check;
using ::sus::assertions::check_with_message;
}

namespace sus::mem {

template <class T>
__attribute__((const)) inline __attribute__((always_inline)) constexpr T&& forward(
 std::remove_reference_t<T>& t) noexcept {
 return static_cast<T&&>(t);
}

template <class T>
__attribute__((const)) inline __attribute__((always_inline)) constexpr T&& forward(
 std::remove_reference_t<T>&& t) noexcept {
 static_assert(!std::is_lvalue_reference_v<T>,
 "Can not convert an rvalue to an lvalue with forward().");
 return static_cast<T&&>(t);
}

}

namespace sus {
using ::sus::mem::forward;
}

namespace sus::fn {
struct Anything;
}

namespace sus::fn::__private {

struct NoOverloadMatchesArguments {};

template <class T>
concept InvalidFunctionSignature = false;

template <class... Ts>
struct ArgsPack;

template <class R, class... A>
struct Sig {
 static_assert(
 InvalidFunctionSignature<R>,
 "expected a function signature of the form `ReturnType(Args...)`");
};

template <class R, class... A>
struct Sig<R(A...)> {
 using Return = R;
 using Args = ArgsPack<A...>;
};

template <class F, class ArgsPack>
struct InvokedFnOnce {
 static NoOverloadMatchesArguments returns();
};

template <class F, class... Ts>
 requires requires(F&& f) {
 { std::invoke(::sus::forward<F>(f), std::declval<Ts>()...) };
 }
struct InvokedFnOnce<F, ArgsPack<Ts...>> {
 static std::invoke_result_t<F&&, Ts...> returns();
};

template <class F, class ArgsPack>
struct InvokedFnMut {
 static NoOverloadMatchesArguments returns();
};

template <class F, class... Ts>
 requires requires(F& f) {
 { std::invoke(f, std::declval<Ts>()...) };
 }
struct InvokedFnMut<F, ArgsPack<Ts...>> {
 static std::invoke_result_t<F, Ts...> returns();
};

template <class F, class ArgsPack>
struct InvokedFn {
 static NoOverloadMatchesArguments returns();
};

template <class F, class... Ts>
 requires requires(const F& f) {
 { std::invoke(f, std::declval<Ts>()...) };
 }
struct InvokedFn<F, ArgsPack<Ts...>> {
 static std::invoke_result_t<const F&, Ts...> returns();
};

template <class ReturnType, class T>
concept ValidReturnType =
 !std::same_as<ReturnType, NoOverloadMatchesArguments> &&
 (std::same_as<::sus::fn::Anything, T> ||
 std::convertible_to<ReturnType, T>);

}

namespace sus::mem {

template <class T>
concept Move =
 std::is_move_constructible_v<
 std::remove_const_t<std::remove_reference_t<T>>> &&
 std::is_move_assignable_v<std::remove_const_t<std::remove_reference_t<T>>>;

template <class T>
concept MoveOrRef = Move<T> || std::is_reference_v<T>;

template <class T>
 requires(!std::is_const_v<std::remove_reference_t<T>>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr decltype(auto) move(T&& t) noexcept {
 return static_cast<std::remove_reference_t<T>&&>(t);
}

template <class T>
concept IsMoveRef = std::is_rvalue_reference_v<T> &&
 !std::is_const_v<std::remove_reference_t<T>>;

}

namespace sus {
using ::sus::mem::move;
}

namespace sus::fn {

struct NonVoid {
 template <class T>
 constexpr NonVoid(T&&) noexcept {}
};

struct Anything {
 template <class T>
 constexpr Anything(T&&) noexcept {}
};

template <class F, class... S>
concept FnOnce = requires {

{
 __private::InvokedFnOnce<F, typename __private::Sig<S...>::Args>::returns()
 } -> __private::ValidReturnType<typename __private::Sig<S...>::Return>;
};

template <class F, class... S>
concept FnMut = requires {

{
 __private::InvokedFnMut<F, typename __private::Sig<S...>::Args>::returns()
 } -> __private::ValidReturnType<typename __private::Sig<S...>::Return>;

requires FnOnce<F, S...>;
};

template <class F, class... S>
concept Fn = requires {

{
 __private::InvokedFn<F, typename __private::Sig<S...>::Args>::returns()
 } -> __private::ValidReturnType<typename __private::Sig<S...>::Return>;

requires FnMut<F, S...>;
 requires FnOnce<F, S...>;
};

template <class F, class... Args>
inline __attribute__((always_inline)) constexpr decltype(auto) call_once(F&& f, Args&&... args)
 requires(::sus::mem::IsMoveRef<decltype(f)>)
{
 return std::invoke(sus::move(f), sus::forward<Args>(args)...);
}

template <class F, class... Args>
 requires(!std::is_const_v<std::remove_reference_t<F>>)
inline __attribute__((always_inline)) constexpr decltype(auto) call_mut(F&& f, Args&&... args) {
 return std::invoke(static_cast<std::remove_reference_t<F>&>(f),
 sus::forward<Args>(args)...);
}

template <class F, class... Args>
inline __attribute__((always_inline)) constexpr decltype(auto) call(F&& f, Args&&... args) {
 return std::invoke(static_cast<const std::remove_reference_t<F>&>(f),
 sus::forward<Args>(args)...);
}

template <class F, class... Args>
 requires(FnOnce<F, Anything(Args...)>)
using ReturnOnce =
 decltype(call_once(std::declval<F&&>(), std::declval<Args>()...));

template <class F, class... Args>
 requires(FnMut<F, Anything(Args...)>)
using ReturnMut =
 decltype(call_mut(std::declval<F&&>(), std::declval<Args>()...));

template <class F, class... Args>
 requires(Fn<F, Anything(Args...)>)
using Return = decltype(call(std::declval<F&&>(), std::declval<Args>()...));

}

namespace sus::cmp {

template <class T>
concept Ordering = (std::same_as<T, std::strong_ordering> ||
 std::same_as<T, std::partial_ordering> ||
 std::same_as<T, std::weak_ordering>);

template <class Lhs, class Rhs = Lhs>
concept StrongOrd = requires(const std::remove_reference_t<Lhs>& lhs,
 const std::remove_reference_t<Rhs>& rhs) {
 { lhs <=> rhs } -> std::same_as<std::strong_ordering>;
};

template <class Lhs, class Rhs = Lhs>
concept Ord =
 StrongOrd<Lhs, Rhs> || requires(const std::remove_reference_t<Lhs>& lhs,
 const std::remove_reference_t<Rhs>& rhs) {
 { lhs <=> rhs } -> std::same_as<std::weak_ordering>;
 };

template <class Lhs, class Rhs = Lhs>
concept PartialOrd =
 Ord<Lhs, Rhs> || StrongOrd<Lhs, Rhs> ||
 requires(const std::remove_reference_t<Lhs>& lhs, const Rhs& rhs) {
 { lhs <=> rhs } -> std::same_as<std::partial_ordering>;
 };

template <class Lhs, class Rhs = Lhs>
concept ExclusiveStrongOrd = StrongOrd<Lhs, Rhs>;

template <class Lhs, class Rhs = Lhs>
concept ExclusiveOrd = (!StrongOrd<Lhs, Rhs> && Ord<Lhs, Rhs>);

template <class Lhs, class Rhs = Lhs>
concept ExclusivePartialOrd = (!Ord<Lhs, Rhs> && PartialOrd<Lhs, Rhs>);

template <class T>
 requires(::sus::cmp::Ord<T>)
inline constexpr T min(T a [[clang::lifetimebound]], T b [[clang::lifetimebound]]) noexcept {
 return a > b ? ::sus::forward<T>(b) : ::sus::forward<T>(a);
}

template <class T>
constexpr T min_by(
 T a [[clang::lifetimebound]], T b [[clang::lifetimebound]],
 ::sus::fn::FnOnce<std::weak_ordering(
 const std::remove_reference_t<T>&,
 const std::remove_reference_t<T>&)> auto compare) noexcept {
 return ::sus::fn::call_once(::sus::move(compare), a, b) ==
 std::weak_ordering::greater
 ? ::sus::forward<T>(b)
 : ::sus::forward<T>(a);
}

template <
 class T,
 ::sus::fn::FnMut<::sus::fn::NonVoid(const std::remove_reference_t<T>&)>
 KeyFn,
 int&...,
 class Key = std::invoke_result_t<KeyFn&, const std::remove_reference_t<T>&>>
 requires(::sus::cmp::Ord<Key>)
constexpr T min_by_key(T a [[clang::lifetimebound]], T b [[clang::lifetimebound]],
 KeyFn f) noexcept {
 return ::sus::fn::call_mut(f, a) > ::sus::fn::call_mut(f, b)
 ? ::sus::forward<T>(b)
 : ::sus::forward<T>(a);
}

template <class T>
 requires(::sus::cmp::Ord<T>)
constexpr T max(T a [[clang::lifetimebound]], T b [[clang::lifetimebound]]) noexcept {
 return a > b ? ::sus::forward<T>(a) : ::sus::forward<T>(b);
}

template <class T>
constexpr T max_by(
 T a [[clang::lifetimebound]], T b [[clang::lifetimebound]],
 ::sus::fn::FnOnce<std::weak_ordering(
 const std::remove_reference_t<T>&,
 const std::remove_reference_t<T>&)> auto compare) noexcept {
 return ::sus::fn::call_once(::sus::move(compare), a, b) ==
 std::weak_ordering::greater
 ? ::sus::forward<T>(a)
 : ::sus::forward<T>(b);
}

template <
 class T,
 ::sus::fn::FnMut<::sus::fn::NonVoid(const std::remove_reference_t<T>&)>
 KeyFn,
 int&...,
 class Key = std::invoke_result_t<KeyFn&, const std::remove_reference_t<T>&>>
 requires(::sus::cmp::Ord<Key>)
constexpr T max_by_key(T a [[clang::lifetimebound]], T b [[clang::lifetimebound]],
 KeyFn f) noexcept {
 return f(a) > f(b) ? ::sus::forward<T>(a) : ::sus::forward<T>(b);
}

template <class T>
 requires(::sus::cmp::Ord<T>)
constexpr T clamp(T v [[clang::lifetimebound]], T min [[clang::lifetimebound]],
 T max [[clang::lifetimebound]]) noexcept {
 ::sus::check(min <= max);
 return v < min ? ::sus::forward<T>(min)
 : (v > max ? ::sus::forward<T>(max) : ::sus::forward<T>(v));
}

}

namespace sus {

namespace collections {}
}

namespace sus::construct {

template <class T>
concept Default = std::constructible_from<T>;

}

namespace sus::choice_type {
template <class TypeListOfMemberTypes, auto... Tags>
class Choice;
}

namespace sus::collections {
template <class T, size_t N>
class Array;
}

namespace sus::collections {
template <class T, size_t N>
struct ArrayIntoIter;
}

namespace sus::collections {
template <class T>
class Slice;
}

namespace sus::collections {
template <class T>
class SliceMut;
}

namespace sus::collections {
template <class T>
struct SliceIter;
}

namespace sus::collections {
template <class T>
struct SliceIterMut;
}

namespace sus::collections {
template <class T>
class Vec;
}

namespace sus::collections {
template <class T>
struct VecIntoIter;
}

namespace sus::fn {
template <class R, class... Args>
class FnOnceRef;
}

namespace sus::fn {
template <class R, class... Args>
class FnMutRef;
}

namespace sus::fn {
template <class R, class... Args>
class FnRef;
}

namespace sus::fn {
template <class R, class... Args>
class FnOnceBox;
}

namespace sus::fn {
template <class R, class... Args>
class FnMutBox;
}

namespace sus::fn {
template <class R, class... Args>
class FnBox;
}

namespace sus::iter {
template <class Iter, class Item>
class IteratorBase;
}

namespace sus::iter {
template <class RefIterator>
class ByRef;
template <class InnerSizedIter, class OtherSizedIter>
class Chain;
template <class InnerSizedIter>
class Cloned;
template <class InnerSizedIter>
class Copied;
template <class InnerSizedIter>
class Cycle;
template <class InnerSizedIter>
class Enumerate;
template <class InnerSizedIter, class Pred>
class Filter;
template <class ToItem, class InnerSizedIter, class FilterMapFn>
class FilterMap;
template <class IntoIterable, class InnerSizedIter, class MapFn>
class FlatMap;
template <class EachIter, class InnerSizedIter>
class Flatten;
template <class InnerIter>
class Fuse;
template <class Item>
class Generator;
template <class InnerSizedIter, class InspectFn>
class Inspect;
template <class ToItem, class InnerSizedIter, class MapFn>
class Map;
template <class ToItem, class InnerSizedIter, class MapFn>
class MapWhile;
template <class InnerSizedIter>
class Moved;
template <class InnerSizedIter>
class Peekable;
template <class InnerSizedIter>
class Reverse;
template <class OutType, class State, class InnerSizedIter, class Fn>
class Scan;
template <class InnerIter>
class Skip;
template <class InnerIter, class Pred>
class SkipWhile;
template <class InnerIter>
class StepBy;
template <class InnerIter>
class Take;
template <class InnerIter, class Pred>
class TakeWhile;
template <class... InnerIters>
class Zip;
template <class Iter>
class IteratorRange;
}

namespace sus::iter {
struct SizeHint;
}

namespace sus::ptr {
template <class T>
 requires(!std::is_reference_v<T>)
class NonNull;
}

namespace sus::num {
struct i8;
struct i16;
struct i32;
struct i64;
struct isize;
struct u8;
struct u16;
struct u32;
struct u64;
struct usize;
struct uptr;
struct f32;
struct f64;
}

namespace sus::option {
template <class T>
class Option;
}

namespace sus::result {
struct OkVoid;
}

namespace sus::result {
template <class T, class E>
class Result;
}

namespace sus::tuple_type {
template <class T, class... Ts>
class Tuple;
}

namespace sus::result::__private {

template <class U>
struct IsResultType final : std::false_type {
 using ok_type = void;
 using err_type = void;
};

template <class U, class V>
struct IsResultType<::sus::result::Result<U, V>> final : std::true_type {
 using ok_type = U;
 using err_type = V;
};

template <class T>
concept IsResult = IsResultType<T>::value;

template <class T, class Success>
concept IsResultWithOkType =
 IsResult<T> && std::same_as<Success, typename IsResultType<T>::ok_type>;

template <class T, class Error>
concept IsResultWithErrType =
 IsResult<T> && std::same_as<Error, typename IsResultType<T>::err_type>;

}

namespace sus::construct {

template <class ToType, class FromType>
concept From = requires(FromType&& from) {
 { ToType::from(::sus::forward<FromType>(from)) } -> std::same_as<ToType>;
};

template <class ToType, class FromType>
concept TryFrom = requires(FromType&& from) {
 {
 ToType::try_from(::sus::forward<FromType>(from))
 } -> ::sus::result::__private::IsResultWithOkType<ToType>;
};

}

namespace sus::construct ::__private {

template <class FromType>
struct IntoRef final {
 [[nodiscard]] constexpr IntoRef(FromType&& from) noexcept
 : from_(::sus::forward<FromType>(from)) {}

template <std::same_as<std::remove_reference_t<FromType>> ToType>
 constexpr operator ToType() && noexcept {
 return static_cast<ToType&&>(from_);
 }

template <::sus::construct::From<FromType> ToType>
 requires(!std::same_as<std::remove_reference_t<FromType>, ToType>)
 constexpr operator ToType() && noexcept {
 return ToType::from(::sus::forward<FromType>(from_));
 }

IntoRef(const IntoRef&) {
 static_assert(std::same_as<FromType, FromType>,
 "into() must immediately be converted to a type by forcing a "
 "conversion, it can not be stored");
 }
 IntoRef& operator=(const IntoRef&) = delete;

private:
  FromType&& from_;
};

}

namespace sus::mem {

template <class T>
concept Copy = std::is_copy_constructible_v<
 std::remove_const_t<std::remove_reference_t<T>>> &&
 (std::is_copy_assignable_v<
 std::remove_const_t<std::remove_reference_t<T>>> ||
 !std::is_move_assignable_v<
 std::remove_const_t<std::remove_reference_t<T>>>);

template <class T>
concept TrivialCopy =
 Copy<T> && std::is_trivially_copyable_v<
 std::remove_const_t<std::remove_reference_t<T>>>;

template <class T>
concept CopyOrRef = Copy<T> || std::is_reference_v<T>;

}

namespace sus::construct {

template <class FromType, class ToType>
concept Into =
 ::sus::construct::From<ToType, FromType> || std::same_as<ToType, FromType>;

template <class FromType>
constexpr inline auto into(FromType&& from [[clang::lifetimebound]]) noexcept {
 return __private::IntoRef<FromType&&>(::sus::forward<FromType>(from));
}

template <class FromType>
 requires(!std::is_const_v<std::remove_reference_t<FromType>> &&
 !std::is_array_v<FromType>)
constexpr inline auto move_into(FromType& from [[clang::lifetimebound]]) noexcept {
 return __private::IntoRef(
 static_cast<std::remove_cv_t<std::remove_reference_t<FromType>>&&>(from));
}

template <class FromType>
 requires(std::is_rvalue_reference_v<FromType &&> &&
 !std::is_const_v<std::remove_reference_t<FromType>> &&
 !std::is_array_v<FromType>)
constexpr inline auto move_into(FromType&& from [[clang::lifetimebound]]) noexcept {
 return __private::IntoRef(
 static_cast<std::remove_cv_t<std::remove_reference_t<FromType>>&&>(from));
}

template <class FromType, class ToType>
concept TryInto = ::sus::construct::TryFrom<ToType, FromType> ||
 std::same_as<ToType, FromType>;

template <class ToType, TryInto<ToType> FromType>
constexpr inline auto try_into(FromType&& from) noexcept {
 return ToType::try_from(::sus::forward<FromType>(from));
}

}

namespace sus {
using ::sus::construct::into;
using ::sus::construct::move_into;
using ::sus::construct::try_into;
}

namespace sus {

namespace boxed {}

}

namespace sus::boxed {

template <class DynC, class ConcreteT>
concept DynConcept = requires {

requires std::same_as<DynC, std::remove_cvref_t<DynC>>;
 requires std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>;

{ DynC::template SatisfiesConcept<ConcreteT> } -> std::same_as<const bool&>;

typename DynC::template DynTyped<ConcreteT, ConcreteT>;

requires DynC::template SatisfiesConcept<DynC>;

requires std::is_base_of_v<
 DynC, typename DynC::template DynTyped<ConcreteT, ConcreteT>>;
 requires std::is_final_v<
 typename DynC::template DynTyped<ConcreteT, ConcreteT>>;

requires !std::is_move_constructible_v<DynC>;
 requires !std::is_move_assignable_v<DynC>;
};

template <class DynC, class ConcreteT>
class [[nodiscard]] Dyn {
 public:
 static_assert(std::same_as<const DynC, const std::remove_cvref_t<DynC>>,
 "DynC can be const-qualified but not a reference");
 static_assert(std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>,
 "ConcreteT can not be qualified or a reference");

static_assert(
 DynC::template SatisfiesConcept<ConcreteT>,
 "ConcreteT must satisfy the concept that DynC type-erases for.");

Dyn(ConcreteT& concrete [[clang::lifetimebound]])
 requires(!std::is_const_v<DynC>)
 : dyn_(concrete) {}

Dyn(ConcreteT&& concrete [[clang::lifetimebound]])
 requires(!std::is_const_v<DynC>)
 : dyn_(concrete) {}

Dyn(const ConcreteT& concrete [[clang::lifetimebound]])
 requires(std::is_const_v<DynC>)

: dyn_(const_cast<ConcreteT&>(concrete)) {}

operator const DynC&() const& { return dyn_; }
 operator DynC&() &
 requires(!std::is_const_v<DynC>)
 {
 return dyn_;
 }
 operator DynC&() &&
 requires(!std::is_const_v<DynC>)
 {
 return dyn_;
 }
 operator DynC&&() &&
 requires(!std::is_const_v<DynC>)
 {
 return ::sus::move(dyn_);
 }

Dyn(Dyn&&) = delete;

Dyn& operator=(Dyn&&) = delete;

private:

typename DynC::template DynTyped<ConcreteT, ConcreteT&> dyn_;
};

template <class DynC, class ConcreteT>
 requires(std::same_as<DynC, std::remove_cvref_t<DynC>> &&
 std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>>)
constexpr Dyn<DynC, ConcreteT> dyn(ConcreteT& t [[clang::lifetimebound]]) noexcept {
 return Dyn<DynC, ConcreteT>(t);
}
template <class DynC, class ConcreteT>
 requires(std::same_as<DynC, std::remove_cvref_t<DynC>> &&
 std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>> &&
 std::is_rvalue_reference_v<ConcreteT &&>)
constexpr Dyn<DynC, ConcreteT> dyn(ConcreteT&& t [[clang::lifetimebound]]) noexcept {
 return Dyn<DynC, ConcreteT>(t);
}
template <class DynC, class ConcreteT>
 requires(std::same_as<const DynC, const std::remove_cvref_t<DynC>> &&
 std::same_as<ConcreteT, std::remove_cvref_t<ConcreteT>> &&
 std::is_const_v<DynC>)
constexpr Dyn<DynC, ConcreteT> dyn(
 const ConcreteT& t [[clang::lifetimebound]]) noexcept {
 return Dyn<DynC, ConcreteT>(t);
}

}

namespace sus {
using sus::boxed::dyn;
}

namespace sus::fn {

template <class T>
struct DynFn;
template <class T>
struct DynFnMut;
template <class T>
struct DynFnOnce;

template <class T, class Store, class R, class... Args>
 requires(Fn<T, R(Args...)>)
struct DynFnTyped;
template <class T, class Store, class R, class... Args>
 requires(FnMut<T, R(Args...)>)
struct DynFnMutTyped;
template <class T, class Store, class R, class... Args>
 requires(FnOnce<T, R(Args...)>)
struct DynFnOnceTyped;

template <class R, class... Args>
struct DynFn<R(Args...)> {
 template <class T>
 static constexpr bool SatisfiesConcept = Fn<T, R(Args...)>;
 template <class T, class Store>
 using DynTyped = DynFnTyped<T, Store, R, Args...>;

static constexpr bool IsDynFn = true;

DynFn() = default;
  virtual ~DynFn() = default;
  DynFn(DynFn&&) = delete;
  DynFn& operator=(DynFn&&) = delete;

virtual R operator()(Args&&...) const = 0;
};

template <class T, class Store, class R, class... Args>
 requires(Fn<T, R(Args...)>)
struct DynFnTyped final : public DynFn<R(Args...)> {
 constexpr DynFnTyped(Store&& c) : c_(sus::forward<Store>(c)) {}

R operator()(Args&&... args) const override {
 return sus::fn::call(c_, ::sus::forward<Args>(args)...);
 }

private:
  Store c_;
};

template <class R, class... Args>
struct DynFnMut<R(Args...)> {
 template <class T>
 static constexpr bool SatisfiesConcept = FnMut<T, R(Args...)>;
 template <class T, class Store>
 using DynTyped = DynFnMutTyped<T, Store, R, Args...>;

static constexpr bool IsDynFn = true;

DynFnMut() = default;
  virtual ~DynFnMut() = default;
  DynFnMut(DynFnMut&&) = delete;
  DynFnMut& operator=(DynFnMut&&) = delete;

virtual R operator()(Args&&...) = 0;
};

template <class T, class Store, class R, class... Args>
 requires(FnMut<T, R(Args...)>)
struct DynFnMutTyped final : public DynFnMut<R(Args...)> {
 constexpr DynFnMutTyped(Store&& c) : c_(sus::forward<Store>(c)) {}

R operator()(Args&&... args) override {
 return call_mut(c_, ::sus::forward<Args>(args)...);
 }

private:
  Store c_;
};

template <class R, class... Args>
struct DynFnOnce<R(Args...)> {
 template <class T>
 static constexpr bool SatisfiesConcept = FnOnce<T, R(Args...)>;
 template <class T, class Store>
 using DynTyped = DynFnOnceTyped<T, Store, R, Args...>;

static constexpr bool IsDynFn = true;

DynFnOnce() = default;
  virtual ~DynFnOnce() = default;
  DynFnOnce(DynFnOnce&&) = delete;
  DynFnOnce& operator=(DynFnOnce&&) = delete;

virtual R operator()(Args&&...) && = 0;
};

template <class T, class Store, class R, class... Args>
 requires(FnOnce<T, R(Args...)>)
struct DynFnOnceTyped final : public DynFnOnce<R(Args...)> {
 constexpr DynFnOnceTyped(Store&& c) : c_(sus::forward<Store>(c)) {}

R operator()(Args&&... args) && override {
 return call_once(::sus::move(c_), ::sus::forward<Args>(args)...);
 }

private:
  Store c_;
};

static_assert(Fn<DynFn<int(double)>, int(double)>);

static_assert(::sus::boxed::DynConcept<DynFn<int(float)>,
 decltype([](float) { return 0; })>);

static_assert(FnMut<DynFnMut<int(double)>, int(double)>);

static_assert(::sus::boxed::DynConcept<DynFnMut<int(float)>,
 decltype([](float) { return 0; })>);

static_assert(FnOnce<DynFnOnce<int(double)>, int(double)>);

static_assert(::sus::boxed::DynConcept<DynFnOnce<int(float)>,
 decltype([](float) { return 0; })>);

}

namespace sus {

namespace fn {}

}

namespace sus::iter::__private {

template <class T>
struct IsGenerator;

template <class T>
struct IsGenerator final : std::false_type {
 using type = void;
};
template <class T>
struct IsGenerator<Generator<T>> final : std::true_type {
 using type = T;
};

}

namespace sus::ptr {

template <class T, class U>
concept SameOrSubclassOf =
 std::is_pointer_v<T> &&
 std::is_pointer_v &&
 std::is_convertible_v<T, U>;

}

namespace sus::iter {

template <class T, class Item>
concept Iterator =
 requires(std::remove_cvref_t<T>& t, const std::remove_cvref_t<T>& c) {

requires(!std::is_void_v<typename std::remove_cvref_t<T>::Item>);

requires(std::same_as<typename std::remove_cvref_t<T>::Item, Item>);

requires ::sus::ptr::SameOrSubclassOf<
 std::remove_cvref_t<T>*, IteratorBase<std::remove_cvref_t<T>, Item>*>;

{ t.next() } noexcept -> std::same_as<::sus::option::Option<Item>>;
 { c.size_hint() } noexcept -> std::same_as<SizeHint>;
 };

template <class T>
concept IteratorAny = requires {
 typename std::remove_cvref_t<T>::Item;
 requires Iterator<T, typename std::remove_cvref_t<T>::Item>;
};

template <class T, class Item = typename std::remove_cvref_t<T>::Item>
concept DoubleEndedIterator =
 Iterator<T, Item> && requires(std::remove_cvref_t<T>& t) {
 { t.next_back() } noexcept -> std::same_as<::sus::option::Option<Item>>;
 };

template <class T, class Item = typename std::remove_cvref_t<T>::Item>
concept ExactSizeIterator =
 Iterator<T, Item> && requires(const std::remove_cvref_t<T>& t) {
 { t.exact_size_hint() } noexcept -> std::same_as<::sus::num::usize>;
 };

namespace __private {
struct TrustedLenMarker {};
}

template <class T>
concept TrustedLen = requires(const std::remove_cvref_t<T>& t) {
 { t.trusted_len() } -> std::same_as<__private::TrustedLenMarker>;
};

}

namespace sus::string::__private {

template <class To, class From>
concept ConvertibleFrom = std::convertible_to<From, To>;

template <class T, class Char>
concept StreamCanReceiveString = requires(T& t, std::basic_string<Char> s) {

{ t << s } -> ConvertibleFrom<T&>;
};

template <class Char, StreamCanReceiveString<Char> S>
S& format_to_stream(S& os, const std::basic_string<Char>& s) {
 os << s;
 return os;
}

}

namespace sus::marker {

struct UnsafeFnMarker {

explicit consteval UnsafeFnMarker() {}
};

constexpr inline auto unsafe_fn = UnsafeFnMarker();

}

template <class Char>
struct fmt::formatter<::sus::marker::UnsafeFnMarker, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return ctx.begin();
 }

template <class FormatContext>
 constexpr auto format(const ::sus::marker::UnsafeFnMarker&,
 FormatContext& ctx) const {
 return fmt::format_to(ctx.out(), "unsafe_fn");
 }
};

namespace sus::marker { using namespace ::sus::string::__private; template< StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const UnsafeFnMarker & value ) { static_assert(fmt::is_formattable<UnsafeFnMarker >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus::assertions {

[[noreturn]] inline __attribute__((always_inline)) void unreachable(
    const std::source_location location = std::source_location::current()) {
  panic(location);
}

[[noreturn]] inline __attribute__((always_inline)) void unreachable_unchecked(
    ::sus::marker::UnsafeFnMarker) {

__builtin_unreachable();

}

namespace sus {
using sus::assertions::unreachable;
using sus::assertions::unreachable_unchecked;
}

namespace sus::iter {

template <class T, class Item>
concept IntoIterator = requires(std::remove_cvref_t<T> t) {
 { ::sus::move(t).into_iter() } -> Iterator<Item>;
};

template <class T>
concept IntoIteratorAny = requires(std::remove_cvref_t<T> t) {
 {
 ::sus::move(t).into_iter()
 } -> Iterator<
 typename std::decay_t<decltype(::sus::move(t).into_iter())>::Item>;
};

template <class T>
 requires(IntoIteratorAny<T>)
using IntoIteratorOutputType = std::decay_t<
 decltype(std::declval<std::remove_cvref_t<T>&&>().into_iter())>;

}

namespace sus::iter::__private {

template <class T>
struct IntoIteratorArchetype {
 template <class Item>
 struct Iter final : public IteratorBase<Iter<Item>, Item> {
 ::sus::option::Option<Item> next() noexcept;
 SizeHint size_hint() const noexcept;
 };
 Iter<T> into_iter() && { return Iter<T>(); }
};

}

namespace sus::iter {

template <class ToType>
struct FromIteratorImpl;

template <class ToType, class ItemType>
concept FromIterator = requires(
 __private::IntoIteratorArchetype<ItemType>&& from) {
 {
 FromIteratorImpl<std::remove_const_t<ToType>>::from_iter(::sus::move(from))
 } -> std::same_as<std::remove_const_t<ToType>>;
};

template <class ToType, IntoIteratorAny IntoIter>
 requires(
 FromIterator<ToType, typename IntoIteratorOutputType<IntoIter>::Item>)
constexpr inline ToType from_iter(IntoIter&& into_iter) noexcept
 requires(::sus::mem::IsMoveRef<decltype(into_iter)>)
{
 return FromIteratorImpl<ToType>::from_iter(
 ::sus::move(into_iter).into_iter());
}

}

namespace sus::iter::__private {

template <class Item>
struct IteratorArchetype final
 : public ::sus::iter::IteratorBase<IteratorArchetype<Item>, Item> {
 ::sus::option::Option<Item> next() noexcept;
 SizeHint size_hint() const noexcept;
};

}

namespace sus::iter {

template <class T, class Item = T>
concept Product = requires(__private::IteratorArchetype<Item>&& iter) {

requires(!std::is_reference_v<T>);
 { T::from_product(::sus::move(iter)) } -> std::same_as<T>;
};

}

namespace sus::iter {

template <class T, class Item = T>
concept Sum = requires(__private::IteratorArchetype<Item>&& iter) {

requires(!std::is_reference_v<T>);
 { T::from_sum(::sus::move(iter)) } -> std::same_as<T>;
};

}

namespace sus::mem::__private {

template <class T>
concept IsTrivialDtorOrRef =
 std::is_trivially_destructible_v<T> || std::is_reference_v<T>;

template <class T>
concept IsTrivialCopyCtorOrRef =
 std::is_trivially_copy_constructible_v<T> || std::is_reference_v<T>;

template <class T>
concept IsTrivialCopyAssignOrRef =
 std::is_trivially_copy_assignable_v<T> || std::is_reference_v<T>;

template <class T>
concept IsTrivialMoveCtorOrRef =
 std::is_trivially_move_constructible_v<T> || std::is_reference_v<T>;

template <class T>
concept IsTrivialMoveAssignOrRef =
 std::is_trivially_move_assignable_v<T> || std::is_reference_v<T>;

}

namespace sus::mem {

namespace __private {

template <class T>
concept HasCloneMethod = requires(const T& source) {
 { source.clone() } -> std::same_as<T>;
};

template <class T>
concept HasCloneFromMethod = requires(T& self, const T& source) {
 { self.clone_from(source) } -> std::same_as<void>;
};

}

template <class T>
concept Clone =
 (Copy<T> && !__private::HasCloneMethod<
 std::remove_const_t<std::remove_reference_t<T>>>) ||
 (!Copy<T> && Move<T> &&
 __private::HasCloneMethod<
 std::remove_const_t<std::remove_reference_t<T>>>);

template <class T>
concept CloneOrRef = Clone<T> || std::is_reference_v<T>;

template <class T>
concept CloneFrom =
 Clone<T> &&
 ((Copy<T> && !__private::HasCloneFromMethod<
 std::remove_const_t<std::remove_reference_t<T>>>) ||
 (!Copy<T> && __private::HasCloneFromMethod<
 std::remove_const_t<std::remove_reference_t<T>>>));

template <Clone T>
[[nodiscard]] inline __attribute__((always_inline)) constexpr std::decay_t<T> clone(
 const T& source) noexcept {
 if constexpr (Copy<T>) {
 return source;
 } else {
 return source.clone();
 }
}

template <CloneOrRef T>
[[nodiscard]] inline __attribute__((always_inline)) constexpr T clone_or_forward(
 const std::remove_reference_t<T>& source) noexcept {
 if constexpr (std::is_reference_v<T>) {
 return source;
 } else {
 return ::sus::mem::clone(source);
 }
}

template <Clone T>
inline __attribute__((always_inline)) constexpr void clone_into(T& dest, const T& source) noexcept {
 if constexpr (Copy<T>) {
 dest = source;
 } else if constexpr (CloneFrom<T>) {
 dest.clone_from(source);
 } else {
 dest = source.clone();
 }
}

}

namespace sus {
using ::sus::mem::clone;
using ::sus::mem::clone_into;
}

namespace sus::mem::__private {

constexpr inline size_t min_size(size_t a, size_t b) { return a < b ? a : b; }

template <class T, size_t bytes>
struct NoUnique {
 [[no_unique_address]] T x;
 char c[bytes];
};

template <class T, size_t bytes>
struct Subclass : T {
 char c[bytes];
};

template <class T, size_t bytes>
constexpr inline size_t data_size_finder_final_class =
 sizeof(T) < sizeof(NoUnique<T, bytes>)
 ? sizeof(T) - bytes + 1
 : data_size_finder_final_class<T, bytes + 1>;

template <class T>
constexpr inline size_t
 data_size_finder_final_class<T, alignof(std::max_align_t) + 1> = size_t(-1);

template <class T, size_t bytes>
constexpr inline size_t data_size_finder_inheritable_class =
 sizeof(T) < min_size(sizeof(NoUnique<T, bytes>), sizeof(Subclass<T, bytes>))
 ? sizeof(T) - bytes + 1
 : data_size_finder_inheritable_class<T, bytes + 1>;

template <class T>
constexpr inline size_t
 data_size_finder_inheritable_class<T, alignof(std::max_align_t) + 1> =
 size_t(-1);

template <class T, size_t bytes>
constexpr inline size_t data_size_finder_union = size_t(-1);

template <class T, size_t bytes = 1u,
 bool is_class = std::is_class_v<T>,
 bool is_final = std::is_final_v<T>,
 bool is_union = std::is_union_v<T>>
constexpr inline size_t data_size_finder = sizeof(T);

template <class T, size_t bytes>
constexpr inline size_t data_size_finder<T, bytes, true, true, false> =
 data_size_finder_final_class<T, bytes>;
template <class T, size_t bytes>
constexpr inline size_t data_size_finder<T, bytes, true, false, false> =
 data_size_finder_inheritable_class<T, bytes>;
template <class T, size_t bytes>
constexpr inline size_t data_size_finder<T, bytes, false, false, true> =
 data_size_finder_union<T, bytes>;

}

namespace sus::mem {

template <class T>
 requires(!std::is_reference_v<T>)
__attribute__((const)) consteval inline __attribute__((always_inline)) size_t size_of() noexcept {
 return sizeof(T);
}

template <class T>
 requires(!std::is_reference_v<T>)
__attribute__((const)) consteval inline __attribute__((always_inline)) size_t data_size_of() noexcept {
 static_assert(alignof(T) <= alignof(std::max_align_t),
 "data_size_of() does not support types with alignment greater "
 "than std::max_align_t.");
 return __private::data_size_finder<T>;
}

}

namespace sus {
using sus::mem::data_size_of;
using sus::mem::size_of;
}

namespace sus::mem {

namespace __private {

template <class T>
struct relocatable_tag final {
 static constexpr bool value(...) { return false; }

static constexpr bool value(int)
 requires requires {
 requires(std::same_as<decltype(T::SusUnsafeTrivialRelocate), const bool>);
 }
 {
 return T::SusUnsafeTrivialRelocate;
 };
};

template <class T>
concept relocate_by_memcpy_impl =
 std::is_reference_v<T>
 || (!std::is_volatile_v<std::remove_all_extents_t<T>>
 && sus::mem::data_size_of<std::remove_all_extents_t<std::remove_reference_t<T>>>() != size_t(-1)
 && (__private::relocatable_tag<std::remove_all_extents_t<T>>::value(0)
 || std::is_trivially_copyable_v<std::remove_all_extents_t<T>>
 || (std::is_trivially_move_constructible_v<std::remove_all_extents_t<T>> &&
 std::is_trivially_move_assignable_v<std::remove_all_extents_t<T>> &&
 std::is_trivially_destructible_v<std::remove_all_extents_t<T>>)

)
       );

}

template <class... T>
concept relocate_by_memcpy = (... && __private::relocate_by_memcpy_impl<T>);

}

namespace sus::mem {

template <class T>
__attribute__((const)) inline constexpr T* addressof(T& arg) noexcept {

return __builtin_addressof(arg);
}

template <class T>
T* addressof(T&& arg) = delete;

}

namespace sus::mem {

template <class T, std::convertible_to<T> U>
 requires(!std::is_array_v<T> &&
 ::sus::mem::Move<T> &&
 !std::is_const_v<T> &&
 (!std::same_as<T, U> || ::sus::mem::Copy<T>))
[[nodiscard]] inline constexpr T replace(T& dest, const U& src) noexcept {
 auto old = T(::sus::move(dest));
 const T& typed_src = src;
 dest = typed_src;
 return old;
}

template <class T, std::convertible_to<T> U>
 requires(!std::is_array_v<T> &&
 ::sus::mem::Move<T> &&
 !std::is_const_v<T>)
[[nodiscard]] inline constexpr T replace(T& dest, U&& src) noexcept
 requires(::sus::mem::IsMoveRef<decltype(src)>)
{
 auto old = T(::sus::move(dest));
 T&& typed_src = ::sus::move(src);
 dest = ::sus::move(typed_src);
 return old;
}

}

namespace sus::mem {

template <class T>
 requires(::sus::mem::Move<T> && ::sus::construct::Default<T> &&
 std::is_final_v<T>)
inline constexpr T take(T& t) noexcept {
 auto taken = T(::sus::move(t));
 t.~T();
 std::construct_at(&t);
 return taken;
}

template <class T>
 requires(::sus::mem::Move<T>)
inline constexpr T take_and_destruct(::sus::marker::UnsafeFnMarker,
 T& t) noexcept {

auto taken = T(static_cast<T&&>(t));
 t.~T();
 return taken;
}

template <class T>
 requires(::sus::mem::Copy<T>)
inline constexpr T take_copy_and_destruct(::sus::marker::UnsafeFnMarker,
 const T& t) noexcept {

auto taken = T(t);
  t.~T();
  return taken;
}

}

namespace sus::ops {

template <class T>
struct TryImpl;

template <class T>
concept Try =
 requires {

requires !std::is_reference_v<T>;

typename TryImpl<std::remove_const_t<T>>::Output;

}
    &&
    requires(const T& t, T&& tt) {

{ TryImpl<std::remove_const_t<T>>::is_success(t) } -> std::same_as<bool>;

{
 TryImpl<std::remove_const_t<T>>::into_output(::sus::move(tt))
 } -> std::same_as<typename TryImpl<std::remove_const_t<T>>::Output>;
 }
 &&

(std::is_void_v<typename TryImpl<std::remove_const_t<T>>::Output> ||
 requires(typename TryImpl<std::remove_const_t<T>>::Output&& output) {

{
 TryImpl<std::remove_const_t<T>>::from_output(
 ::sus::forward<typename TryImpl<std::remove_const_t<T>>::Output>(
 output))
 } -> std::same_as<T>;
 });

template <class T>
concept TryDefault = Try<T> && requires {

{ TryImpl<std::remove_const_t<T>>::from_default() } -> std::same_as<T>;
};

template <class From, class To>
concept TryErrorConvertibleTo =
 Try<From> &&
 Try<To> &&
 requires(From&& f) {

{
 TryImpl<To>::template preserve_error(::sus::move(f))
 } -> std::same_as<To>;
 };

template <Try T>
using TryOutputType = typename TryImpl<std::remove_const_t<T>>::Output;

template <Try T, class U>
using TryRemapOutputType =
 typename TryImpl<std::remove_const_t<T>>::template RemapOutput;

template <Try T>
constexpr inline bool try_is_success(const T& t) noexcept {
 return TryImpl<std::remove_cvref_t<T>>::is_success(t);
}

template <Try T>
constexpr inline TryImpl<std::remove_cvref_t<T>>::Output try_into_output(
 T&& t) noexcept
 requires(::sus::mem::IsMoveRef<decltype(t)>)
{
 ::sus::check(TryImpl<std::remove_cvref_t<T>>::is_success(t));
 return TryImpl<std::remove_cvref_t<T>>::into_output(::sus::move(t));
}

template <Try T>
 requires(!std::is_const_v<T> &&
 !std::is_reference_v<T> &&
 !std::is_void_v<typename TryImpl<T>::Output>)
constexpr inline T try_from_output(typename TryImpl<T>::Output&& t) noexcept {
 return TryImpl<T>::from_output(
 ::sus::forward<typename TryImpl<T>::Output>(t));
}

template <TryDefault T>
 requires(!std::is_const_v<T> &&
 !std::is_reference_v<T>)
constexpr inline T try_from_default() noexcept {
 return TryImpl<T>::from_default();
}

template <class U, TryErrorConvertibleTo T>
 requires(!std::is_const_v &&
 !std::is_reference_v)
constexpr inline U try_preserve_error(T&& t) noexcept
 requires(::sus::mem::IsMoveRef<decltype(t)>)
{
 ::sus::check(!TryImpl<std::remove_cvref_t<T>>::is_success(t));
 return TryImpl::preserve_error(::sus::move(t));
}

}

namespace sus::option::__private {

template <class U>
struct IsOptionType final : std::false_type {
 using inner_type = void;
};

template <class U>
struct IsOptionType<Option> final : std::true_type {
 using inner_type = U;
};

}

namespace sus::option::__private {

template <class U>
struct IsTupleOfSizeTwo final {
 static constexpr bool value = false;
 using first_type = void;
 using second_type = void;
};

template <class U, class V>
struct IsTupleOfSizeTwo<::sus::tuple_type::Tuple<U, V>> final {
 static constexpr bool value = true;
 using first_type = U;
 using second_type = V;
};

}

namespace sus::construct {

namespace __private {
template <class T>
concept IsConstLvalueReference = std::is_lvalue_reference_v<T> &&
 std::is_const_v<std::remove_reference_t<T>>;

}

template <class To, class From>
concept SafelyConstructibleFromReference =
 !__private::IsConstLvalueReference<To> ||

std::same_as<std::remove_cvref_t<From>, std::remove_cvref_t<To>> ||

sus::ptr::SameOrSubclassOf<std::remove_cvref_t<From>*,
 std::remove_cvref_t<To>*>;

}

namespace sus::mem {

namespace __private {
template <class T>
struct remove_rvalue_reference_helper {
 using type = T;
};

template <class T>
struct remove_rvalue_reference_helper<T&&> {
 using type = T;
};

}

template <class T>
using remove_rvalue_reference = __private::remove_rvalue_reference_helper<T>::type;

}

namespace sus::option::__private {

template <class T>
struct [[nodiscard]] SomeMarker {
 explicit constexpr SomeMarker(T&& value) : value(::sus::forward<T>(value)) {}

T&& value;

template <class U>
 inline constexpr operator Option() const& noexcept {
 static_assert(
 std::convertible_to<::sus::mem::remove_rvalue_reference<T>, U>,
 "SomeMarker(T) can't convert const T& to U for Option. "
 "Note that this is a test-only code path for Gtest support. "
 "Typically the T object is consumed as an rvalue, consider using "
 "EXPECT_TRUE(a == b) if needed.");
 static_assert(std::convertible_to<T&&, U>,
 "SomeMarker(T) can't convert T to U for Option");
 static_assert(
 ::sus::construct::SafelyConstructibleFromReference<U, const T&>,
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The SomeMarker's value type "
 "must match the Option's. For example an `Option<const i32&>` can not "
 "be constructed from a SomeMarker holding `const i16&`, but it can be "
 "constructed from `i32&&`.");
 return Option(U(value));
 }

template <class U>
 inline constexpr operator Option() && noexcept {
 static_assert(std::convertible_to<T&&, U>,
 "SomeMarker(T) can't convert T to U for Option");
 static_assert(
 ::sus::construct::SafelyConstructibleFromReference<U, T&&>,
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The SomeMarker's value type "
 "must match the Option's. For example an `Option<const i32&>` can not "
 "be constructed from a SomeMarker holding `const i16&`, but it can be "
 "constructed from `i32&&`.");
 return Option(::sus::forward<T>(value));
 }

SomeMarker(SomeMarker&&) = delete;
  SomeMarker& operator=(SomeMarker&&) = delete;
};

struct [[nodiscard]] NoneMarker {
  explicit constexpr NoneMarker() = default;

template <class U>
 __attribute__((const)) inline constexpr operator Option() const& noexcept {
 return Option();
 }

template <class U>
 __attribute__((const)) inline constexpr operator Option() && noexcept {
 return Option();
 }

NoneMarker(NoneMarker&&) = delete;
  NoneMarker& operator=(NoneMarker&&) = delete;
};

}

namespace sus::mem {

struct NeverValueConstructor {};

namespace __private {

template <class T>
struct NeverValueAccess;

template <class T>
struct NeverValueAccess<T&> {
 static constexpr bool has_field = false;
};

template <class T>
struct NeverValueChecker {
 static constexpr bool has_field = requires {
 std::declval<T&>()._sus_Unsafe_NeverValueIsConstructed(
 ::sus::marker::unsafe_fn);
 };
};

template <class T>
struct NeverValueAccess {
 constexpr NeverValueAccess() = default;

template <class... U>
 requires(sizeof...(U) > 0u)
 constexpr NeverValueAccess(U&&... v) : t_(::sus::forward(v)...) {}

__attribute__((pure)) constexpr inline __attribute__((always_inline)) bool is_constructed() const noexcept
 requires(NeverValueChecker<T>::has_field)
 {
 return t_._sus_Unsafe_NeverValueIsConstructed(::sus::marker::unsafe_fn);
 }

constexpr inline __attribute__((always_inline)) void set_destroy_value(
 ::sus::marker::UnsafeFnMarker) noexcept
 requires(NeverValueChecker<T>::has_field)
 {
 t_._sus_Unsafe_NeverValueSetDestroyValue(::sus::marker::unsafe_fn);
 }

__attribute__((pure)) constexpr inline __attribute__((always_inline)) const T& as_inner() const { return t_; }
  __attribute__((pure)) constexpr inline __attribute__((always_inline)) T& as_inner_mut() { return t_; }

private:
  T t_{NeverValueConstructor()};

};

}

template <class T>
concept NeverValueField = __private::NeverValueChecker<T>::has_field;

}

namespace sus::option {

enum class State : bool {

None,

Some,
};

}

namespace sus::option::__private {

using State::None;
using State::Some;

template <class T, bool = sus::mem::NeverValueField<T>>
struct Storage;

template <class T>
struct Storage<T, false> final {
 constexpr ~Storage()
 requires(std::is_trivially_destructible_v<T>)
 = default;
 constexpr ~Storage()
 requires(!std::is_trivially_destructible_v<T>)
 {}

constexpr Storage(const Storage&)
 requires(std::is_trivially_copy_constructible_v<T>)
 = default;
 constexpr Storage& operator=(const Storage&)
 requires(std::is_trivially_copy_assignable_v<T>)
 = default;
 constexpr Storage(Storage&&)
 requires(std::is_trivially_move_constructible_v<T>)
 = default;
 constexpr Storage& operator=(Storage&&)
 requires(std::is_trivially_move_assignable_v<T>)
 = default;

constexpr Storage(const Storage& o) noexcept
 requires(!std::is_trivially_copy_constructible_v<T>)
 : state_(o.state()) {
 if (state_ == Some) std::construct_at(&val_, o.val());
 }
 constexpr void operator=(const Storage& o) noexcept
 requires(!std::is_trivially_copy_assignable_v<T>)
 {
 if (o.state() == Some)
 set_some(o.val());
 else if (state() == Some)
 set_none();
 }
 constexpr Storage(Storage&& o) noexcept
 requires(!std::is_trivially_move_constructible_v<T>)
 : state_(o.state()) {
 if (state_ == Some) std::construct_at(&val_, o.take_and_set_none());
 }
 constexpr void operator=(Storage&& o) noexcept
 requires(!std::is_trivially_move_assignable_v<T>)
 {
 if (o.state() == Some)
 set_some(o.take_and_set_none());
 else if (state() == Some)
 set_none();
 }

constexpr Storage() noexcept {}
 constexpr Storage(const std::remove_cvref_t<T>& t) noexcept
 : val_(t), state_(Some) {}
 constexpr Storage(std::remove_cvref_t<T>& t) noexcept
 : val_(t), state_(Some) {}
 constexpr Storage(std::remove_cvref_t<T>&& t) noexcept
 : val_(::sus::move(t)), state_(Some) {}

template <class U>
 requires(std::convertible_to<U, T>)
 constexpr Storage(const Storage& o) noexcept : state_(o.state()) {
 if (state_ == Some) std::construct_at(&val_, o.val());
 }
 template <class U>
 requires(std::convertible_to)
 constexpr Storage(Storage&& o) noexcept : state_(o.state()) {
 if (state_ == Some) std::construct_at(&val_, o.take_and_set_none());
 }

__attribute__((pure)) constexpr const T& val() const noexcept { return val_; }
  __attribute__((pure)) constexpr T& val_mut() noexcept { return val_; }

__attribute__((pure)) constexpr inline State state() const noexcept { return state_; }

constexpr inline void construct_from_none(const T& t) noexcept
 requires(::sus::mem::Copy<T>)
 {
 std::construct_at(&val_, t);
 state_ = Some;
 }
 constexpr inline void construct_from_none(T&& t) noexcept {
 std::construct_at(&val_, ::sus::move(t));
 state_ = Some;
 }

constexpr inline void set_some(const T& t) noexcept
 requires(::sus::mem::Copy<T>)
 {
 if (state_ == None)
 construct_from_none(t);
 else
 val_ = t;
 state_ = Some;
 }
 constexpr inline void set_some(T&& t) noexcept {
 if (state_ == None)
 construct_from_none(::sus::move(t));
 else
 val_ = ::sus::move(t);
 state_ = Some;
 }

[[nodiscard]] constexpr inline T replace_some(T&& t) noexcept {
    return ::sus::mem::replace(val_, ::sus::move(t));
  }

[[nodiscard]] constexpr inline T take_and_set_none() noexcept {
 state_ = None;
 if constexpr (std::is_trivially_copyable_v<T>) {
 return ::sus::mem::take_copy_and_destruct(::sus::marker::unsafe_fn, val_);
 } else if constexpr (::sus::mem::Move<T>) {
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn, val_);
 } else {
 return ::sus::mem::take_copy_and_destruct(::sus::marker::unsafe_fn, val_);
 }
 }

constexpr inline void set_none() noexcept {
    state_ = None;
    val_.~T();
  }

constexpr inline void destroy() noexcept { val_.~T(); }

private:
  union {
    T val_;
  };
  State state_ = None;

};

template <class T>
struct Storage<T, true> final {
 constexpr ~Storage()
 requires(std::is_trivially_destructible_v<T>)
 = default;
 constexpr ~Storage()
 requires(!std::is_trivially_destructible_v<T>)
 {}

constexpr Storage(const Storage& o) noexcept
 requires(!std::is_trivially_copy_constructible_v<T>)
 {
 if (o.state() == Some)
 std::construct_at(&access_, o.val());
 else
 std::construct_at(&access_);
 }
 constexpr void operator=(const Storage& o) noexcept
 requires(!std::is_trivially_copy_assignable_v<T>)
 {
 if (o.state() == Some)
 set_some(o.val());
 else if (state() == Some)
 set_none();
 }
 constexpr Storage(Storage&& o) noexcept
 requires(!std::is_trivially_move_constructible_v<T>)
 {
 if (o.state() == Some)
 std::construct_at(&access_, o.take_and_set_none());
 else
 std::construct_at(&access_);
 }
 constexpr void operator=(Storage&& o) noexcept
 requires(!std::is_trivially_move_assignable_v<T>)
 {
 if (o.state() == Some)
 set_some(o.take_and_set_none());
 else if (state() == Some)
 set_none();
 }

constexpr Storage() noexcept : access_() {}
  constexpr Storage(const T& t) noexcept : access_(t) {}
  constexpr Storage(T&& t) noexcept : access_(::sus::move(t)) {}

template <class U>
 requires(std::convertible_to<U, T>)
 constexpr Storage(const Storage& o) noexcept {
 if (o.state() == Some)
 std::construct_at(&access_, o.val());
 else
 std::construct_at(&access_);
 }
 template <class U>
 requires(std::convertible_to)
 constexpr Storage(Storage&& o) noexcept {
 if (o.state() == Some)
 std::construct_at(&access_, o.take_and_set_none());
 else
 std::construct_at(&access_);
 }

__attribute__((pure)) constexpr const T& val() const noexcept {
    return access_.as_inner();
  };
  __attribute__((pure)) constexpr T& val_mut() noexcept { return access_.as_inner_mut(); };

__attribute__((pure)) constexpr inline State state() const noexcept {
    return access_.is_constructed() ? Some : None;
  }

constexpr inline void construct_from_none(const T& t) noexcept
 requires(::sus::mem::Copy<T>)
 {
 access_.set_destroy_value(::sus::marker::unsafe_fn);
 access_.~NeverValueAccess();
 std::construct_at(&access_, t);
 }
 constexpr inline void construct_from_none(T&& t) noexcept {
 access_.set_destroy_value(::sus::marker::unsafe_fn);
 access_.~NeverValueAccess();
 std::construct_at(&access_, ::sus::move(t));
 }

constexpr inline void set_some(const T& t) noexcept
 requires(::sus::mem::Copy<T>)
 {
 if (state() == None)
 construct_from_none(t);
 else
 access_.as_inner_mut() = t;
 }
 constexpr inline void set_some(T&& t) noexcept {
 if (state() == None)
 construct_from_none(::sus::move(t));
 else
 access_.as_inner_mut() = ::sus::move(t);
 }

[[nodiscard]] constexpr inline T replace_some(T&& t) noexcept {
    return ::sus::mem::replace(access_.as_inner_mut(), ::sus::move(t));
  }

[[nodiscard]] constexpr inline T take_and_set_none() noexcept {
    auto t = T(::sus::move(access_.as_inner_mut()));
    access_.~NeverValueAccess();
    std::construct_at(&access_);
    return t;
  }

constexpr inline void set_none() noexcept {
    access_.~NeverValueAccess();
    std::construct_at(&access_);
  }

constexpr inline void destroy() noexcept {
    if (!access_.is_constructed())
      access_.set_destroy_value(::sus::marker::unsafe_fn);
    access_.~NeverValueAccess();
  }

private:
 using NeverValueAccess = ::sus::mem::__private::NeverValueAccess<T>;

union {
    NeverValueAccess access_;
  };

};

template <class T>
struct StoragePointer {};

template <class T>
struct [[clang::trivial_abi]] StoragePointer<T&> {
 explicit constexpr inline __attribute__((always_inline)) StoragePointer(T& ref) noexcept
 : ptr_(::sus::mem::addressof(ref)) {}

template <class U>
 requires(std::convertible_to<U&, T&>)

constexpr inline __attribute__((always_inline)) StoragePointer(
 const StoragePointer<U&>& other) noexcept
 : ptr_(other.ptr_) {}

constexpr operator const T&() const { return *ptr_; }
  constexpr operator T&() { return *ptr_; }

private:
 template <class U>
 friend struct StoragePointer;

T* ptr_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ptr_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

private: static_assert( std::same_as<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class> friend struct ::sus::mem::__private::NeverValueAccess; template <class> friend struct ::sus::mem::__private::NeverValueChecker; __attribute__((pure)) constexpr bool _sus_Unsafe_NeverValueIsConstructed( ::sus::marker::UnsafeFnMarker) const noexcept { static_assert( std::is_assignable_v<decltype(ptr_)&, decltype(nullptr)>, "The `never_value` must be able to be assigned to the named field."); return !(ptr_ == nullptr); } constexpr void _sus_Unsafe_NeverValueSetDestroyValue( ::sus::marker::UnsafeFnMarker) noexcept { static_assert(::sus::cmp::Eq<decltype(ptr_), decltype(nullptr)>, "The `never_value` must be comparable to the named field."); ptr_ = nullptr; } static_assert(true);

explicit constexpr StoragePointer(::sus::mem::NeverValueConstructor) noexcept
      : ptr_(nullptr) {}
};

static_assert(std::is_trivially_copy_constructible_v<StoragePointer<int&>>);
static_assert(std::is_trivially_copy_assignable_v<StoragePointer<int&>>);
static_assert(std::is_trivially_move_constructible_v<StoragePointer<int&>>);
static_assert(std::is_trivially_move_assignable_v<StoragePointer<int&>>);

static_assert(::sus::mem::NeverValueField<StoragePointer<int&>>);

}

namespace sus::string::__private {

template <class Char>
auto format_bytes(auto out, fmt::string_view bytes) {
 for (size_t i = 0; i < bytes.size(); i += 1) {
 const auto p = static_cast<unsigned char>(bytes[i]);
 const auto low = p % 16;
 const auto high = p / 16;
 if (high > 9)
 *out++ = static_cast<Char>('a' + high - 10);
 else
 *out++ = static_cast<Char>('0' + high);
 if (low > 9)
 *out++ = static_cast<Char>('a' + low - 10);
 else
 *out++ = static_cast<Char>('0' + low);
 if (i < bytes.size() - 1) *out++ = static_cast<Char>('-');
 }
 return out;
}

template <class Char>
struct BytesFormatter {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return ctx.begin();
 }

template <class T, class FormatContext>
 constexpr auto format(const T& t, FormatContext& ctx) const {
 constexpr size_t num_bytes = ::sus::mem::data_size_of<T>()
 ? ::sus::mem::data_size_of<T>()
 : ::sus::mem::size_of<T>();
 return format_bytes<Char>(
 ctx.out(),
 fmt::string_view(reinterpret_cast<const char*>(&t), num_bytes));
 }
};

}

namespace sus::string::__private {

struct VoidPlaceholder {};

template <class T, class Char>
using AnyFormatter = std::conditional_t<
 fmt::is_formattable<
 std::remove_cv_t<std::remove_reference_t<
 std::conditional_t<std::is_void_v<T>, VoidPlaceholder, T>>>,
 Char>::value,
 fmt::formatter<std::remove_cv_t<std::remove_reference_t<std::conditional_t<
 std::is_void_v<T>, VoidPlaceholder, T>>>,
 Char>,
 BytesFormatter<Char>>;

template <class Char>
auto format_void(auto out) {
 *out++ = static_cast<Char>('<');
 *out++ = static_cast<Char>('v');
 *out++ = static_cast<Char>('o');
 *out++ = static_cast<Char>('i');
 *out++ = static_cast<Char>('d');
 *out++ = static_cast<Char>('>');
 return out;
}

template <class Char>
struct VoidFormatter {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return ctx.begin();
 }

template <class FormatContext>
 constexpr auto format(FormatContext& ctx) const {
 return format_void<Char>(ctx.out());
 }
};

template <class T, class Char>
using AnyOrVoidFormatter =
 std::conditional_t<std::is_void_v<T>, VoidFormatter<Char>,
 AnyFormatter<T, Char>>;

}

namespace sus::iter {
template <class T>
 requires requires(const T& t) {
 { t.iter() };
 }
constexpr auto begin(const T& t) noexcept;
template <class T>
 requires requires(const T& t) {
 { t.iter() };
 }
constexpr auto end(const T& t) noexcept;
}

namespace sus {

namespace option {}

}

namespace sus::option {
using namespace sus::option::__private;

template <class Item>
class OptionIter;

namespace __private {
template <class T, ::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Product<T>
constexpr Option<T> from_product_impl(Iter&& it) noexcept;
template <class T, ::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Sum<T>
constexpr Option<T> from_sum_impl(Iter&& it) noexcept;
}

template <class T>
class Option final {

static_assert(!std::is_const_v<T>,
 "`Option<const T>` should be written `const Option<T>`, as "
 "const applies transitively.");
 static_assert(
 !std::is_rvalue_reference_v<T>,
 "`Option<T&&> is not supported, use Option<T&> or Option<const T&.");

public:

inline constexpr Option() noexcept = default;

explicit constexpr Option(const T& t) noexcept
 requires(!std::is_reference_v<T> &&
 ::sus::mem::Copy<T>)
 : Option(WITH_SOME, t) {}

template <std::convertible_to<T> U>
 explicit constexpr Option(U&& u) noexcept
 requires(!std::is_reference_v<T> &&
 ::sus::mem::Move<T> &&
 ::sus::mem::IsMoveRef<decltype(u)>)
 : Option(WITH_SOME, move_to_storage(u)) {}

template <std::convertible_to<T> U>
 explicit constexpr Option(U&& t [[clang::lifetimebound]]) noexcept
 requires(std::is_reference_v<T> &&
 sus::construct::SafelyConstructibleFromReference<T, U &&>)
 : Option(WITH_SOME, move_to_storage(t)) {}

template <class U>
 requires(std::convertible_to<U, T> &&
 std::is_reference_v == std::is_reference_v<T>)
 constexpr Option(const Option& other) : t_(other.t_) {}

template <class U>
 requires(std::convertible_to &&
 std::is_reference_v == std::is_reference_v<T>)
 constexpr Option(Option&& other) : t_(::sus::move(other.t_)) {}

template <class U>
 requires(!std::is_reference_v && std::is_reference_v<T>)
 constexpr Option(Option&& other) = delete;

template <class U>
 requires(std::constructible_from<Option, U &&>)
 static constexpr Option from(U&& val) noexcept
 requires(!std::is_reference_v<T>)
 {
 return Option(sus::forward(val));
 }

template <class U>
 requires(std::constructible_from<Option, U &&>)
 static constexpr Option from(U&& val [[clang::lifetimebound]]) noexcept
 requires(std::is_reference_v<T>)
 {
 return Option(::sus::forward(val));
 }

template <::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Product<T>
 static constexpr Option from_product(Iter&& it) noexcept {
 return __private::from_product_impl<T>(::sus::move(it));
 }

template <::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Sum<T>
 static constexpr Option from_sum(Iter&& it) noexcept {
 return __private::from_sum_impl<T>(::sus::move(it));
 }

constexpr ~Option() noexcept
 requires(::sus::mem::__private::IsTrivialDtorOrRef<T>)
 = default;

constexpr inline ~Option() noexcept
 requires(!::sus::mem::__private::IsTrivialDtorOrRef<T>)
 {
 if (t_.state() == Some) t_.destroy();
 }

constexpr Option(const Option& o)
 requires(::sus::mem::CopyOrRef<T>)
 = default;

constexpr Option(const Option& o)
 requires(!::sus::mem::CopyOrRef<T>)
 = delete;

constexpr Option(Option&& o)
 requires(::sus::mem::MoveOrRef<T>)
 = default;

constexpr Option(Option&& o)
 requires(!::sus::mem::MoveOrRef<T>)
 = delete;

constexpr Option& operator=(const Option& o)
 requires(::sus::mem::CopyOrRef<T>)
 = default;

constexpr Option& operator=(const Option& o)
 requires(!::sus::mem::CopyOrRef<T>)
 = delete;

constexpr Option& operator=(Option&& o)
 requires(::sus::mem::MoveOrRef<T>)
 = default;

constexpr Option& operator=(Option&& o)
 requires(!::sus::mem::MoveOrRef<T>)
 = delete;

constexpr Option clone() const& noexcept
 requires(::sus::mem::Clone<T> && !::sus::mem::CopyOrRef<T>)
 {
 if (t_.state() == Some)
 return Option(::sus::clone(t_.val()));
 else
 return Option();
 }

constexpr void clone_from(const Option& source) & noexcept
 requires(::sus::mem::Clone<T> && !::sus::mem::CopyOrRef<T>)
 {
 if (&source == this) [[unlikely]]
 return;
 if (t_.state() == Some && source.t_.state() == Some) {
 ::sus::clone_into(t_.val_mut(), source.t_.val());
 } else {
 *this = source.clone();
 }
 }

__attribute__((pure)) constexpr bool is_some() const noexcept {
    return t_.state() == Some;
  }

__attribute__((pure)) constexpr bool is_none() const noexcept {
    return t_.state() == None;
  }

__attribute__((pure)) constexpr operator State() const& { return t_.state(); }

constexpr __attribute__((nonnull)) T expect(
 const char* _Nonnull
 message) && noexcept {
 ::sus::check_with_message(t_.state() == Some, message);
 return ::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn);
 }
 constexpr __attribute__((nonnull)) T expect(
 const char* _Nonnull
 message) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).expect(message);
 }

constexpr T unwrap() && noexcept {
 ::sus::check(t_.state() == Some);
 return ::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn);
 }
 constexpr T unwrap() const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).unwrap();
 }

constexpr T unwrap_or(T default_result) && noexcept {
 if (t_.state() == Some) {
 return t_.take_and_set_none();
 } else {
 return default_result;
 }
 }
 constexpr T unwrap_or(T default_result) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).unwrap_or(::sus::move(default_result));
 }

constexpr T unwrap_or_else(::sus::fn::FnOnce<T()> auto f) && noexcept {
 if (t_.state() == Some) {
 return t_.take_and_set_none();
 } else {
 return ::sus::fn::call_once(::sus::move(f));
 }
 }
 constexpr T unwrap_or_else(::sus::fn::FnOnce<T()> auto f) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).unwrap_or_else(::sus::move(f));
 }

constexpr T unwrap_or_default() && noexcept
 requires(!std::is_reference_v<T> &&
 ::sus::construct::Default<T>)
 {
 if (t_.state() == Some) {
 return t_.take_and_set_none();
 } else {
 return T();
 }
 }
 constexpr T unwrap_or_default() const& noexcept
 requires(!std::is_reference_v<T> &&
 ::sus::construct::Default<T> &&
 ::sus::mem::Copy<T>)
 {
 return ::sus::clone(*this).unwrap_or_default();
 }

constexpr inline T unwrap_unchecked(
 ::sus::marker::UnsafeFnMarker) && noexcept {
 if (t_.state() == Some)
 return t_.take_and_set_none();
 else
 __builtin_unreachable();
 }
 constexpr inline T unwrap_unchecked(
 ::sus::marker::UnsafeFnMarker) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 if (t_.state() == Some)
 return ::sus::clone(*this).t_.take_and_set_none();
 else
 __builtin_unreachable();
 }

__attribute__((pure)) constexpr const std::remove_reference_t<T>& as_value()
 const& noexcept {
 ::sus::check(t_.state() == Some);
 return t_.val();
 }
 __attribute__((pure)) constexpr const std::remove_reference_t<T>& as_value() && noexcept
 requires(std::is_reference_v<T>)
 {
 ::sus::check(t_.state() == Some);
 return t_.val();
 }

__attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_mut() & noexcept {
 ::sus::check(t_.state() == Some);
 return t_.val_mut();
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_mut() && noexcept
 requires(std::is_reference_v<T>)
 {
 ::sus::check(t_.state() == Some);
 return t_.val_mut();
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_mut() const& noexcept
 requires(std::is_reference_v<T>)
 {
 return ::sus::clone(*this).as_value_mut();
 }

__attribute__((pure)) constexpr const std::remove_reference_t<T>& as_value_unchecked(
 ::sus::marker::UnsafeFnMarker) const& noexcept {
 return t_.val();
 }
 __attribute__((pure)) constexpr const std::remove_reference_t<T>& as_value_unchecked(
 ::sus::marker::UnsafeFnMarker) && noexcept
 requires(std::is_reference_v<T>)
 {
 return t_.val();
 }

__attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_unchecked_mut(
 ::sus::marker::UnsafeFnMarker) & noexcept {
 return t_.val_mut();
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_unchecked_mut(
 ::sus::marker::UnsafeFnMarker) && noexcept
 requires(std::is_reference_v<T>)
 {
 return t_.val_mut();
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>& as_value_unchecked_mut(
 ::sus::marker::UnsafeFnMarker) const& noexcept
 requires(std::is_reference_v<T>)
 {
 return ::sus::clone(*this).as_value_unchecked_mut(::sus::marker::unsafe_fn);
 }

__attribute__((pure)) constexpr const std::remove_reference_t<T>& operator*()
 const& noexcept {
 ::sus::check(t_.state() == Some);
 return t_.val();
 }
 __attribute__((pure)) constexpr const std::remove_reference_t<T>& operator*() && noexcept
 requires(std::is_reference_v<T>)
 {
 ::sus::check(t_.state() == Some);
 return t_.val();
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>& operator*() & noexcept {
 ::sus::check(t_.state() == Some);
 return t_.val_mut();
 }

__attribute__((pure)) constexpr const std::remove_reference_t<T>* operator->()
 const& noexcept {
 ::sus::check(t_.state() == Some);
 return ::sus::mem::addressof(
 static_cast<const std::remove_reference_t<T>&>(t_.val()));
 }
 __attribute__((pure)) constexpr const std::remove_reference_t<T>* operator->() && noexcept
 requires(std::is_reference_v<T>)
 {
 ::sus::check(t_.state() == Some);
 return ::sus::mem::addressof(
 static_cast<const std::remove_reference_t<T>&>(t_.val()));
 }
 __attribute__((pure)) constexpr std::remove_reference_t<T>* operator->() & noexcept {
 ::sus::check(t_.state() == Some);
 return ::sus::mem::addressof(
 static_cast<std::remove_reference_t<T>&>(t_.val_mut()));
 }

constexpr T& insert(T value) & noexcept
 requires(!std::is_reference_v<T> &&
 sus::mem::Move<T>)
 {
 t_.set_some(move_to_storage(value));
 return t_.val_mut();
 }
 template <std::convertible_to<T> U>
 constexpr T& insert(U&& value) & noexcept
 requires(std::is_reference_v<T> &&
 sus::construct::SafelyConstructibleFromReference<T, U &&>)
 {
 t_.set_some(move_to_storage(value));
 return t_.val_mut();
 }

constexpr T& get_or_insert(T value) & noexcept [[clang::lifetimebound]]
 requires(!std::is_reference_v<T> &&
 sus::mem::Move<T>)
 {
 if (t_.state() == None) {
 t_.construct_from_none(move_to_storage(value));
 }
 return t_.val_mut();
 }
 template <std::convertible_to<T> U>
 constexpr T& get_or_insert(U&& value) & noexcept [[clang::lifetimebound]]
 requires(std::is_reference_v<T> &&
 sus::construct::SafelyConstructibleFromReference<T, U &&>)
 {
 if (t_.state() == None) {
 t_.construct_from_none(move_to_storage(value));
 }
 return t_.val_mut();
 }

constexpr T& get_or_insert_default() & noexcept [[clang::lifetimebound]]
 requires(::sus::construct::Default<T>)
 {
 if (t_.state() == None) t_.construct_from_none(T());
 return t_.val_mut();
 }

constexpr T& get_or_insert_with(::sus::fn::FnOnce<T()> auto f) & noexcept {
 if (t_.state() == None) {
 t_.construct_from_none(
 move_to_storage(::sus::fn::call_once(::sus::move(f))));
 }
 return t_.val_mut();
 }

constexpr Option take() & noexcept {
    if (t_.state() == Some)
      return Option(WITH_SOME, t_.take_and_set_none());
    else
      return Option();
  }

template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> MapFn>
 constexpr Option<sus::fn::ReturnOnce<MapFn, T&&>> map(MapFn m) && noexcept {
 if (t_.state() == Some) {
 return Option<sus::fn::ReturnOnce<MapFn, T&&>>(::sus::fn::call_once(
 ::sus::move(m), ::sus::forward<T>(t_.take_and_set_none())));
 } else {
 return Option<sus::fn::ReturnOnce<MapFn, T&&>>();
 }
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> MapFn>
 constexpr Option<sus::fn::ReturnOnce<MapFn, T&&>> map(MapFn m) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).map(::sus::move(m));
 }

template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> MapFn>
 constexpr sus::fn::ReturnOnce<MapFn, T&&> map_or(
 sus::fn::ReturnOnce<MapFn, T&&> default_result, MapFn m) && noexcept {
 if (t_.state() == Some) {
 return ::sus::fn::call_once(::sus::move(m),
 ::sus::forward<T>(t_.take_and_set_none()));
 } else {
 return default_result;
 }
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> MapFn>
 constexpr sus::fn::ReturnOnce<MapFn, T&&> map_or(
 sus::fn::ReturnOnce<MapFn, T&&> default_result, MapFn m) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).map_or(
 ::sus::forward<decltype(default_result)>(default_result),
 ::sus::move(m));
 }

template <::sus::fn::FnOnce<::sus::fn::NonVoid()> DefaultFn,
 ::sus::fn::FnOnce<::sus::fn::ReturnOnce<DefaultFn>(T&&)> MapFn>
 constexpr sus::fn::ReturnOnce<DefaultFn> map_or_else(DefaultFn default_fn,
 MapFn m) && noexcept {
 if (t_.state() == Some) {
 return ::sus::fn::call_once(::sus::move(m),
 ::sus::forward<T>(t_.take_and_set_none()));
 } else {
 return ::sus::fn::call_once(::sus::move(default_fn));
 }
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid()> DefaultFn,
 ::sus::fn::FnOnce<::sus::fn::ReturnOnce<DefaultFn>(T&&)> MapFn>
 constexpr sus::fn::ReturnOnce<DefaultFn> map_or_else(DefaultFn default_fn,
 MapFn m) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).map_or_else(::sus::move(default_fn),
 ::sus::move(m));
 }

constexpr Option<T> filter(
 ::sus::fn::FnOnce<bool(const std::remove_reference_t<T>&)> auto
 p) && noexcept {
 if (t_.state() == Some) {
 if (::sus::fn::call_once(
 ::sus::move(p),
 static_cast<const std::remove_reference_t<T>&>(t_.val()))) {
 return Option(WITH_SOME, t_.take_and_set_none());
 } else {

t_.set_none();
 return Option();
 }
 } else {
 return Option();
 }
 }
 constexpr Option<T> filter(
 ::sus::fn::FnOnce<bool(const std::remove_reference_t<T>&)> auto p)
 const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).filter(::sus::move(p));
 }

template <class U>
 constexpr Option and_that(Option that) && noexcept {
 if (t_.state() == Some) {
 t_.set_none();
 } else {
 that = Option();
 }
 return that;
 }
 template <class U>
 constexpr Option and_that(Option that) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).and_that(::sus::move(that));
 }

template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> AndFn>
 requires(__private::IsOptionType<sus::fn::ReturnOnce<AndFn, T &&>>::value)
 constexpr sus::fn::ReturnOnce<AndFn, T&&> and_then(AndFn f) && noexcept {
 if (t_.state() == Some) {
 return ::sus::fn::call_once(::sus::move(f),
 ::sus::forward<T>(t_.take_and_set_none()));
 } else {
 return sus::fn::ReturnOnce<AndFn, T&&>();
 }
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid(T&&)> AndFn>
 requires(__private::IsOptionType<sus::fn::ReturnOnce<AndFn, T &&>>::value)
 constexpr sus::fn::ReturnOnce<AndFn, T&&> and_then(AndFn f) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).and_then(::sus::move(f));
 }

constexpr Option<T> or_that(Option<T> that) && noexcept {
 if (t_.state() == Some)
 return Option(WITH_SOME, t_.take_and_set_none());
 else
 return that;
 }
 constexpr Option<T> or_that(Option<T> that) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).or_that(::sus::move(that));
 }

constexpr Option<T> or_else(
 ::sus::fn::FnOnce<Option<T>()> auto f) && noexcept {
 if (t_.state() == Some)
 return Option(WITH_SOME, t_.take_and_set_none());
 else
 return ::sus::fn::call_once(::sus::move(f));
 }
 constexpr Option<T> or_else(
 ::sus::fn::FnOnce<Option<T>()> auto f) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).or_else(::sus::move(f));
 }

constexpr Option<T> xor_that(Option<T> that) && noexcept {
 if (t_.state() == Some) {

if (that.t_.state() == None) {
        return Option(WITH_SOME, t_.take_and_set_none());
      } else {
        t_.set_none();
        return Option();
      }
    } else {

return that;
 }
 }
 constexpr Option<T> xor_that(Option<T> that) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).xor_that(::sus::move(that));
 }

template <class E, int&..., class Result = ::sus::result::Result<T, E>>
 constexpr Result ok_or(E e) && noexcept
 requires(!std::is_reference_v<T> && !std::is_reference_v<E>)
 {
 if (t_.state() == Some)
 return Result(t_.take_and_set_none());
 else
 return Result::with_err(::sus::move(e));
 }
 template <class E, int&..., class Result = ::sus::result::Result<T, E>>
 constexpr Result ok_or(E e) const& noexcept
 requires(!std::is_reference_v<T> && !std::is_reference_v<E> &&
 ::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).ok_or(::sus::move(e));
 }

template <::sus::fn::FnOnce<::sus::fn::NonVoid()> ElseFn>
 constexpr sus::result::Result<T, sus::fn::ReturnOnce<ElseFn>> ok_or_else(
 ElseFn f) && noexcept
 requires(!std::is_reference_v<T> &&
 !std::is_reference_v<sus::fn::ReturnOnce<ElseFn>>)
 {
 using R = sus::result::Result<T, sus::fn::ReturnOnce<ElseFn>>;
 if (t_.state() == Some)
 return R(t_.take_and_set_none());
 else
 return R::with_err(::sus::fn::call_once(::sus::move(f)));
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid()> ElseFn>
 constexpr sus::result::Result<T, sus::fn::ReturnOnce<ElseFn>> ok_or_else(
 ElseFn f) const& noexcept
 requires(!std::is_reference_v<T> &&
 !std::is_reference_v<sus::fn::ReturnOnce<ElseFn>> &&
 ::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).ok_or_else(::sus::move(f));
 }

template <int&...,
 class OkType =
 typename ::sus::result::__private::IsResultType<T>::ok_type,
 class ErrType =
 typename ::sus::result::__private::IsResultType<T>::err_type,
 class Result = ::sus::result::Result<Option<OkType>, ErrType>>
 requires(::sus::result::__private::IsResultType<T>::value)
 constexpr Result transpose() && noexcept {
 if (t_.state() == None) {
 return Result(Option<OkType>());
 } else {
 if (t_.val().is_ok()) {
 return Result(Option<OkType>(
 Option<OkType>::WITH_SOME,
 t_.take_and_set_none().unwrap_unchecked(::sus::marker::unsafe_fn)));
 } else {
 return Result::with_err(t_.take_and_set_none().unwrap_err_unchecked(
 ::sus::marker::unsafe_fn));
 }
 }
 }
 template <int&...,
 class OkType =
 typename ::sus::result::__private::IsResultType<T>::ok_type,
 class ErrType =
 typename ::sus::result::__private::IsResultType<T>::err_type,
 class Result = ::sus::result::Result<Option<OkType>, ErrType>>
 requires(::sus::result::__private::IsResultType<T>::value)
 constexpr Result transpose() const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).transpose();
 }

template <class U, int&..., class Tuple = ::sus::tuple_type::Tuple<T, U>>
 constexpr Option<Tuple> zip(Option o) && noexcept {
 if (o.t_.state() == None) {
 if (t_.state() == Some) t_.set_none();
 return Option<Tuple>();
 } else if (t_.state() == None) {
 return Option<Tuple>();
 } else {

return Option<Tuple>(
 Option<Tuple>::WITH_SOME,
 Tuple(::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn),
 ::sus::move(o).unwrap_unchecked(::sus::marker::unsafe_fn)));
 }
 }
 template <class U, int&..., class Tuple = ::sus::tuple_type::Tuple<T, U>>
 constexpr Option<Tuple> zip(Option o) const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).zip(::sus::move(o));
 }

constexpr auto unzip() && noexcept
 requires(!std::is_reference_v<T> && __private::IsTupleOfSizeTwo<T>::value)
 {
 using U = __private::IsTupleOfSizeTwo<T>::first_type;
 using V = __private::IsTupleOfSizeTwo<T>::second_type;
 if (is_some()) {
 auto&& [u, v] = t_.take_and_set_none();
 return ::sus::tuple_type::Tuple<Option, Option<V>>(
 Option(::sus::forward(u)), Option<V>(::sus::forward<V>(v)));
 } else {
 return ::sus::tuple_type::Tuple<Option, Option<V>>(Option(),
 Option<V>());
 }
 }
 constexpr auto unzip() const& noexcept
 requires(!std::is_reference_v<T> && __private::IsTupleOfSizeTwo<T>::value &&
 ::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).unzip();
 }

constexpr Option replace(T value) & noexcept
 requires(!std::is_reference_v<T> &&
 sus::mem::Move<T>)
 {
 if (t_.state() == None) {
 t_.construct_from_none(move_to_storage(value));
 return Option();
 } else {
 return Option(WITH_SOME, t_.replace_some(move_to_storage(value)));
 }
 }
 template <std::convertible_to<T> U>
 constexpr Option replace(U&& value) & noexcept
 requires(std::is_reference_v<T> &&
 sus::construct::SafelyConstructibleFromReference<T, U &&>)
 {
 if (t_.state() == None) {
 t_.construct_from_none(move_to_storage(value));
 return Option();
 } else {
 return Option(WITH_SOME, t_.replace_some(move_to_storage(value)));
 }
 }

constexpr Option<std::remove_const_t<std::remove_reference_t<T>>> copied()
 const& noexcept
 requires(std::is_reference_v<T> && ::sus::mem::Copy<T>)
 {
 if (t_.state() == None) {
 return Option<std::remove_const_t<std::remove_reference_t<T>>>();
 } else {
 return Option<std::remove_const_t<std::remove_reference_t<T>>>(
 Option<std::remove_const_t<std::remove_reference_t<T>>>::WITH_SOME,
 t_.val());
 }
 }

constexpr Option<std::remove_const_t<std::remove_reference_t<T>>> cloned()
 const& noexcept
 requires(std::is_reference_v<T> && ::sus::mem::Clone<T>)
 {
 if (t_.state() == None) {
 return Option<std::remove_const_t<std::remove_reference_t<T>>>();
 } else {

return Option<std::remove_const_t<std::remove_reference_t<T>>>(
 Option<std::remove_const_t<std::remove_reference_t<T>>>::WITH_SOME,
 ::sus::clone(
 static_cast<const std::remove_reference_t<T>&>(t_.val())));
 }
 }

constexpr T flatten() && noexcept
 requires(::sus::option::__private::IsOptionType<T>::value)
 {
 if (t_.state() == Some)
 return ::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn);
 else
 return T();
 }
 constexpr T flatten() const& noexcept
 requires(::sus::option::__private::IsOptionType<T>::value &&
 ::sus::mem::CopyOrRef<T>)
 {
 return ::sus::clone(*this).flatten();
 }

__attribute__((pure)) constexpr Option<const std::remove_reference_t<T>&> as_ref()
 const& noexcept {
 if (t_.state() == None)
 return Option<const std::remove_reference_t<T>&>();
 else
 return Option<const std::remove_reference_t<T>&>(
 Option<const std::remove_reference_t<T>&>::WITH_SOME, t_.val());
 }
 __attribute__((pure)) constexpr Option<const std::remove_reference_t<T>&>
 as_ref() && noexcept
 requires(std::is_reference_v<T>)
 {
 if (t_.state() == None)
 return Option<const std::remove_reference_t<T>&>();
 else
 return Option<const std::remove_reference_t<T>&>(
 Option<const std::remove_reference_t<T>&>::WITH_SOME,
 t_.take_and_set_none());
 }

__attribute__((pure)) constexpr Option<T&> as_mut() & noexcept {
 if (t_.state() == None)
 return Option<T&>();
 else
 return Option<T&>(Option<T&>::WITH_SOME, t_.val_mut());
 }

__attribute__((pure)) constexpr Option<T&> as_mut() && noexcept
 requires(std::is_reference_v<T>)
 {
 if (t_.state() == None)
 return Option<T&>();
 else
 return Option<T&>(Option<T&>::WITH_SOME, t_.take_and_set_none());
 }
 __attribute__((pure)) constexpr Option<T&> as_mut() const& noexcept
 requires(std::is_reference_v<T>)
 {
 return ::sus::clone(*this).as_mut();
 }

__attribute__((pure)) constexpr OptionIter<const std::remove_reference_t<T>&> iter()
 const& noexcept;
 constexpr OptionIter<const std::remove_reference_t<T>&> iter() && noexcept
 requires(std::is_reference_v<T>);
 constexpr OptionIter<const std::remove_reference_t<T>&> iter() const& noexcept
 requires(std::is_reference_v<T>);

__attribute__((pure)) constexpr OptionIter<T&> iter_mut() & noexcept;
 constexpr OptionIter<T&> iter_mut() && noexcept
 requires(std::is_reference_v<T>);
 constexpr OptionIter<T&> iter_mut() const& noexcept
 requires(std::is_reference_v<T>);

constexpr OptionIter<T> into_iter() && noexcept;
 constexpr OptionIter<T> into_iter() const& noexcept
 requires(::sus::mem::CopyOrRef<T>);

friend constexpr inline bool operator==(const Option& l,
 const Option& r) noexcept
 requires(::sus::cmp::Eq<T>)
 {
 switch (l) {
 case Some:
 return r.is_some() && (l.as_value_unchecked(::sus::marker::unsafe_fn) ==
 r.as_value_unchecked(::sus::marker::unsafe_fn));
 case None: return r.is_none();
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const Option<T>& l,
 const Option& r) noexcept {
 switch (l) {
 case Some:
 return r.is_some() && (l.as_value_unchecked(::sus::marker::unsafe_fn) ==
 r.as_value_unchecked(::sus::marker::unsafe_fn));
 case None: return r.is_none();
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

template <class U>
 requires(!::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const Option<T>& l,
 const Option& r) = delete;

friend constexpr inline std::strong_ordering operator<=>(
 const Option& l, const Option& r) noexcept
 requires(::sus::cmp::ExclusiveStrongOrd<T>)
 {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::strong_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::strong_ordering::less;
 else
 return std::strong_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U>
 requires(::sus::cmp::ExclusiveStrongOrd<T, U>)
 friend constexpr inline std::strong_ordering operator<=>(
 const Option<T>& l, const Option& r) noexcept {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::strong_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::strong_ordering::less;
 else
 return std::strong_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

friend constexpr inline std::weak_ordering operator<=>(
 const Option& l, const Option& r) noexcept
 requires(::sus::cmp::ExclusiveOrd<T>)
 {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::weak_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::weak_ordering::less;
 else
 return std::weak_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U>
 requires(::sus::cmp::ExclusiveOrd<T, U>)
 friend constexpr inline std::weak_ordering operator<=>(
 const Option<T>& l, const Option& r) noexcept {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::weak_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::weak_ordering::less;
 else
 return std::weak_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

template <class U>
 requires(::sus::cmp::ExclusivePartialOrd<T, U>)
 friend constexpr inline std::partial_ordering operator<=>(
 const Option<T>& l, const Option& r) noexcept {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::partial_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::partial_ordering::less;
 else
 return std::partial_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 friend constexpr inline std::partial_ordering operator<=>(
 const Option& l, const Option& r) noexcept
 requires(::sus::cmp::ExclusivePartialOrd<T>)
 {
 switch (l) {
 case Some:
 if (r.is_some()) {
 return l.as_value_unchecked(::sus::marker::unsafe_fn) <=>
 r.as_value_unchecked(::sus::marker::unsafe_fn);
 } else {
 return std::partial_ordering::greater;
 }
 case None:
 if (r.is_some())
 return std::partial_ordering::less;
 else
 return std::partial_ordering::equivalent;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

template <class U>
 requires(!::sus::cmp::PartialOrd<T, U>)
 friend constexpr inline auto operator<=>(
 const Option<T>& l, const Option& r) noexcept = delete;

template <class U>
 requires(std::convertible_to)
 constexpr Option(std::optional&& s) noexcept
 requires(!std::is_reference_v<T>)
 : Option() {
 if (s.has_value()) t_.set_some(move_to_storage(::sus::move(s).value()));
 }

template <class U>
 requires(std::convertible_to<const U&, T>)
 constexpr Option(const std::optional& s) noexcept
 requires(!std::is_reference_v<T>)
 : Option() {
 if (s.has_value()) t_.set_some(copy_to_storage(s.value()));
 }

template <class U>
 requires(std::convertible_to<const std::remove_reference_t<T>&, U>)
 constexpr operator std::optional() const& noexcept {
 if (is_some()) {
 return std::optional(std::in_place,
 as_value_unchecked(::sus::marker::unsafe_fn));
 } else {
 return std::nullopt;
 }
 }

template <class U>
 requires(std::convertible_to<T, U>)
 constexpr operator std::optional() && noexcept {
 if (is_some()) {
 return std::optional(
 std::in_place,
 ::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn));
 } else {
 return std::nullopt;
 }
 }

constexpr operator std::optional<const std::remove_reference_t<T>*>()
 const& noexcept
 requires(std::is_reference_v<T>)
 {
 if (is_some()) {
 return std::optional<const std::remove_reference_t<T>*>(
 ::sus::mem::addressof(as_value()));
 } else {
 return std::nullopt;
 }
 }

constexpr operator std::optional<std::remove_reference_t<T>*>()
 const& noexcept
 requires(!std::is_const_v<std::remove_reference_t<T>> &&
 std::is_reference_v<T>)
 {
 if (is_some()) {
 return std::optional<std::remove_reference_t<T>*>(
 ::sus::mem::addressof(as_value_mut()));
 } else {
 return std::nullopt;
 }
 }

private:
 template <class U>
 friend class Option;

template <class U>
 static constexpr inline decltype(auto) copy_to_storage(const U& t) {
 if constexpr (std::is_reference_v<T>)
 return StoragePointer<T>(t);
 else
 return t;
 }

template <class U>
 static constexpr inline decltype(auto) move_to_storage(U&& t) {
 if constexpr (std::is_reference_v<T>) {
 return StoragePointer<T>(::sus::forward(t));
 } else {
 return ::sus::move(t);
 }
 }

enum WithSome { WITH_SOME };
 constexpr explicit Option(WithSome, T t)
 requires(std::is_reference_v<T>)
 : t_(StoragePointer<T>(t)) {}
 constexpr explicit Option(WithSome, const T& t)
 requires(!std::is_reference_v<T>)
 : t_(t) {}
 constexpr explicit Option(WithSome, T&& t)
 requires(!std::is_reference_v<T> && ::sus::mem::Move<T>)
 : t_(::sus::move(t)) {}

template <class U>
 using StorageType =
 std::conditional_t<std::is_reference_v, Storage<StoragePointer>,
 Storage>;
 StorageType<T> t_;

};

template <class T>
Option(T) -> Option<std::remove_cvref_t<T>>;

using ::sus::iter::begin;

using ::sus::iter::end;

template <class T>
[[nodiscard]] inline constexpr __private::SomeMarker<T&&> some(
 T&& t [[clang::lifetimebound]]) noexcept {
 return __private::SomeMarker<T&&>(::sus::forward<T>(t));
}

__attribute__((const)) inline constexpr auto none() noexcept {
  return __private::NoneMarker();
}

}

template <class T>
struct sus::ops::TryImpl<::sus::option::Option<T>> {
 using Output = T;
 template <class U>
 using RemapOutput = ::sus::option::Option;
 constexpr static bool is_success(const ::sus::option::Option<T>& t) noexcept {
 return t.is_some();
 }
 constexpr static Output into_output(::sus::option::Option<T> t) noexcept {

return ::sus::move(t).unwrap_unchecked(::sus::marker::unsafe_fn);
 }
 constexpr static ::sus::option::Option<T> from_output(Output t) noexcept {
 return ::sus::option::Option<T>(::sus::move(t));
 }
 template <class U>
 constexpr static ::sus::option::Option<T> preserve_error(
 ::sus::option::Option) noexcept {

return ::sus::option::Option<T>();
 }

constexpr static ::sus::option::Option<T> from_default() noexcept
 requires(sus::construct::Default<T>)
 {
 return ::sus::option::Option<T>(T());
 }
};

template <class T>
struct std::hash<::sus::option::Option<T>> {
 auto operator()(const ::sus::option::Option<T>& u) const noexcept {
 if (u.is_some())
 return std::hash<T>()(*u);
 else
 return 0;
 }
};
template <class T>
 requires(::sus::cmp::Eq<T>)
struct std::equal_to<::sus::option::Option<T>> {
 constexpr auto operator()(const ::sus::option::Option<T>& l,
 const ::sus::option::Option<T>& r) const noexcept {
 return l == r;
 }
};

template <class T, class Char>
struct fmt::formatter<::sus::option::Option<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::option::Option<T>& t,
 FormatContext& ctx) const {
 if (t.is_none()) {
 return fmt::format_to(ctx.out(), "None");
 } else {
 auto out = ctx.out();
 out = fmt::format_to(out, "Some(");
 ctx.advance_to(out);
 out = underlying_.format(t.as_value(), ctx);
 return fmt::format_to(out, ")");
 }
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::option { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const Option <T>& value ) { static_assert(fmt::is_formattable<Option <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus {
using ::sus::option::none;
using ::sus::option::None;
using ::sus::option::Option;
using ::sus::option::some;
using ::sus::option::Some;
}

namespace sus::num::__private::int_log10 {

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t less_than_5(
    uint32_t val) noexcept {

constexpr uint32_t C1 = 0b011'00000000000000000 - 10;
  constexpr uint32_t C2 = 0b100'00000000000000000 - 100;
  constexpr uint32_t C3 = 0b111'00000000000000000 - 1000;
  constexpr uint32_t C4 = 0b100'00000000000000000 - 10000;

return (((val + C1) & (val + C2)) ^ ((val + C3) & (val + C4))) >> 17;
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t u8(uint8_t val) {
  return less_than_5(uint32_t{val});
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t u16(uint16_t val) noexcept {
  return less_than_5(uint32_t{val});
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t u32(uint32_t val) noexcept {
  auto log = uint32_t{0};
  if (val >= 100'000) {
    val /= 100'000;
    log += 5;
  }
  return log + less_than_5(val);
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t u64(uint64_t val) noexcept {
 auto log = uint32_t{0};
 if (val >= 10'000'000'000) {
 val /= 10'000'000'000;
 log += 10;
 }
 if (val >= 100'000) {
 val /= 100'000;
 log += 5;
 }
 return log + less_than_5(static_cast<uint32_t>(val));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t usize(
 std::same_as<uint32_t> auto val) noexcept {
 return u32(val);
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t usize(
 std::same_as<uint64_t> auto val) noexcept {
 return u64(val);
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t uptr(
 std::same_as<uint32_t> auto val) noexcept {
 return u32(val);
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t uptr(
 std::same_as<uint64_t> auto val) noexcept {
 return u64(val);
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t i8(int8_t val) {
 return u8(static_cast<uint8_t>(val));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t i16(int16_t val) noexcept {
 return u16(static_cast<uint16_t>(val));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t i32(int32_t val) noexcept {
 return u32(static_cast<uint32_t>(val));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t i64(int64_t val) noexcept {
 return u64(static_cast<uint64_t>(val));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t isize(
 int32_t val) noexcept {
 return usize(static_cast<uint32_t>(val));
}

constexpr inline __attribute__((always_inline)) uint32_t isize(int64_t val) noexcept {
 return usize(static_cast<uint64_t>(val));
}

}

namespace sus::num {

enum class FpCategory { Nan, Infinite, Zero, Subnormal, Normal };

}

namespace sus::num::__private {

template <class T>
struct OverflowOut final {
 bool overflow;
 T value;
};

template <class T>
 requires(std::is_integral_v<T>)
using MathType = std::conditional_t<
 ::sus::mem::size_of<T>() >= ::sus::mem::size_of<int>(), T,
 std::conditional_t<std::is_signed_v<T>, int, unsigned int>>;

template <class T>
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t
unchecked_sizeof() noexcept {
 static_assert(::sus::mem::size_of<T>() <= 0xfffffff);
 return static_cast<uint32_t>(::sus::mem::size_of<T>());
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_neg(T x) noexcept {
 return static_cast<T>(-MathType<T>{x});
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_not(T x) noexcept {
 return static_cast<T>(~MathType<T>{x});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_add(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} + MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_sub(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} - MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_mul(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} * MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_div(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} / MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_rem(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} % MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_and(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} & MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_or(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} | MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_xor(T x, T y) noexcept {
 return static_cast<T>(MathType<T>{x} ^ MathType<T>{y});
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_shl(
 T x, uint64_t y) noexcept {
 return static_cast<T>(MathType<T>{x} << y);
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T unchecked_shr(
 T x, uint64_t y) noexcept {
 return static_cast<T>(MathType<T>{x} >> y);
}

template <class T>
 requires(std::is_integral_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t num_bits() noexcept {
 return unchecked_mul(unchecked_sizeof<T>(), uint32_t{8});
}

template <class T>
 requires(std::is_integral_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T high_bit() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return static_cast<T>(0x80);
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return static_cast<T>(0x8000);
 else if constexpr (::sus::mem::size_of<T>() == 4)
 return static_cast<T>(0x80000000);
 else
 return static_cast<T>(0x8000000000000000);
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() == 4)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t high_bit() noexcept {
 return uint32_t{0x80000000};
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() == 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint64_t high_bit() noexcept {
 return uint64_t{0x8000000000000000};
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_value() noexcept {
 return unchecked_not(T{0});
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_value() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return T{0x7f};
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return T{0x7fff};
 else if constexpr (::sus::mem::size_of<T>() == 4)
 return T{0x7fffffff};
 else
 return T{0x7fffffffffffffff};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_int64_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 9223371487098961920.f;
  } else {

return 9223372036854774784.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_int32_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 2147483520.f;
  } else {

return 2147483648.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_int16_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 32767.f;
  } else {

return 32767.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_int8_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 127.f;
  } else {

return 127.0;
  }
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_int64_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return -9223371487098961920.f;
  } else {

return -9223372036854774784.0;
  }
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_int32_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return -2147483520.f;
  } else {

return -2147483649.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_int16_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return -32768.f;
  } else {

return -32768.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_int8_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return -128.f;
  } else {

return -128.0;
  }
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_uint64_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 18446742974197923840.f;
  } else {

return 18446744073709549568.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_uint32_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 4294967040.f;
  } else {

return 4294967295.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_uint16_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 65535.f;
  } else {

return 65535.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_uint8_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 255.f;
  } else {

return 255.0;
  }
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_uint64_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 0.f;
  } else {

return 0.0;
  }
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_uint32_float() noexcept {

if constexpr (::sus::mem::size_of<T>() == 4) {

return 0.f;
  } else {

return 0.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_uint16_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 0.f;
  } else {

return 0.0;
 }
}
template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_uint8_float() noexcept {
 if constexpr (::sus::mem::size_of<T>() == 4) {

return 0.f;
  } else {

return 0.0;
  }
}

template <class I, class T>
 requires(std::is_floating_point_v<T> && std::is_integral_v &&
 ::sus::mem::size_of() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_int_float() noexcept {
 if constexpr (std::is_signed_v) {
 if constexpr (::sus::mem::size_of() == 8)
 return max_int64_float<T>();
 else if constexpr (::sus::mem::size_of() == 4)
 return max_int32_float<T>();
 else if constexpr (::sus::mem::size_of() == 2)
 return max_int16_float<T>();
 else
 return max_int8_float<T>();
 } else {
 if constexpr (::sus::mem::size_of() == 8)
 return max_uint64_float<T>();
 else if constexpr (::sus::mem::size_of() == 4)
 return max_uint32_float<T>();
 else if constexpr (::sus::mem::size_of() == 2)
 return max_uint16_float<T>();
 else
 return max_uint8_float<T>();
 }
}

template <class I, class T>
 requires(std::is_floating_point_v<T> && std::is_integral_v &&
 ::sus::mem::size_of() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_int_float() noexcept {
 if constexpr (std::is_signed_v) {
 if constexpr (::sus::mem::size_of() == 8)
 return min_int64_float<T>();
 else if constexpr (::sus::mem::size_of() == 4)
 return min_int32_float<T>();
 else if constexpr (::sus::mem::size_of() == 2)
 return min_int16_float<T>();
 else
 return min_int8_float<T>();
 } else {
 if constexpr (::sus::mem::size_of() == 8)
 return min_uint64_float<T>();
 else if constexpr (::sus::mem::size_of() == 4)
 return min_uint32_float<T>();
 else if constexpr (::sus::mem::size_of() == 2)
 return min_uint16_float<T>();
 else
 return min_uint8_float<T>();
 }
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_value() noexcept {
 return T{0};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T epsilon() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return 1.1920929E-7f;
 else
 return 2.2204460492503131E-16;
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T max_value() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>()) {
 return 340282346638528859811704183484516925440.f;
 } else
 return 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_value() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return -340282346638528859811704183484516925440.f;
 else
 return -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
}

if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned int>()) {
 using U = unsigned int;
 return static_cast<uint32_t>(__builtin_popcount(U{value}));
 } else if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned long>()) {
 using U = unsigned long;
 return static_cast<uint32_t>(__builtin_popcountl(U{value}));
 } else {
 using U = unsigned long long;
 return static_cast<uint32_t>(__builtin_popcountll(U{value}));
 }

}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t leading_zeros_nonzero(
 ::sus::marker::UnsafeFnMarker, T value) noexcept {
 if (std::is_constant_evaluated()) {
 uint32_t count = 0;
 for (auto i = uint32_t{0};
 i < unchecked_mul(unchecked_sizeof<T>(), uint32_t{8}); ++i) {
 const bool zero = (value & high_bit<T>()) == 0;
 if (!zero) break;
 count += 1;
 value <<= 1;
 }
 return count;
 }

if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned int>()) {
 using U = unsigned int;
 return static_cast<uint32_t>(
 __builtin_clz(U{value}) -
 ((::sus::mem::size_of<unsigned int>() - ::sus::mem::size_of<T>()) *
 8u));
 } else if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned long>()) {
 using U = unsigned long;
 return static_cast<uint32_t>(__builtin_clzl(U{value}));
 } else {
 using U = unsigned long long;
 return static_cast<uint32_t>(__builtin_clzll(U{value}));
 }

}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t leading_zeros(
 T value) noexcept {
 if (value == 0) return unchecked_mul(unchecked_sizeof<T>(), uint32_t{8});
 return leading_zeros_nonzero(::sus::marker::unsafe_fn, value);
}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t trailing_zeros_nonzero(
 ::sus::marker::UnsafeFnMarker, T value) noexcept {
 if (std::is_constant_evaluated()) {
 uint32_t count = 0;
 for (auto i = uint32_t{0};
 i < unchecked_mul(unchecked_sizeof<T>(), uint32_t{8}); ++i) {
 const bool zero = (value & 1) == 0;
 if (!zero) break;
 count += 1;
 value >>= 1;
 }
 return count;
 }

if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned int>()) {
 using U = unsigned int;
 return static_cast<uint32_t>(__builtin_ctz(U{value}));
 } else if constexpr (::sus::mem::size_of<T>() <=
 ::sus::mem::size_of<unsigned long>()) {
 using U = unsigned long;
 return static_cast<uint32_t>(__builtin_ctzl(U{value}));
 } else {
 using U = unsigned long long;
 return static_cast<uint32_t>(__builtin_ctzll(U{value}));
 }

}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t trailing_zeros(
 T value) noexcept {
 if (value == 0) return static_cast<uint32_t>(::sus::mem::size_of<T>() * 8u);
 return trailing_zeros_nonzero(::sus::marker::unsafe_fn, value);
}

if constexpr (::sus::mem::size_of<T>() == 1) {
 return __builtin_bitreverse8(value);
 } else if constexpr (::sus::mem::size_of<T>() == 2) {
 return __builtin_bitreverse16(value);
 } else if constexpr (::sus::mem::size_of<T>() == 4) {
 return __builtin_bitreverse32(value);
 } else {
 static_assert(::sus::mem::size_of<T>() == 8);
 return __builtin_bitreverse64(value);
 }

}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T>)
__attribute__((const)) inline constexpr T rotate_left(T value, uint32_t n) noexcept {
 const uint32_t num_bits = unchecked_mul(unchecked_sizeof<T>(), uint32_t{8});

if (n >= num_bits) n %= num_bits;
  if (n == 0) return value;
  const auto rshift = unchecked_sub(num_bits, n);
  return unchecked_shl(value, n) | unchecked_shr(value, rshift);
}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T>)
__attribute__((const)) inline constexpr T rotate_right(T value, uint32_t n) noexcept {
 const uint32_t num_bits = unchecked_mul(unchecked_sizeof<T>(), uint32_t{8});

if (n >= num_bits) n %= num_bits;
  if (n == 0) return value;
  const auto lshift = unchecked_sub(num_bits, n);
  return unchecked_shr(value, n) | unchecked_shl(value, lshift);
}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T swap_bytes(T value) noexcept {
 if (std::is_constant_evaluated()) {
 if constexpr (::sus::mem::size_of<T>() == 1) {
 return value;
 } else if constexpr (::sus::mem::size_of<T>() == 2) {
 unsigned char a = (value >> 0) & 0xff;
 unsigned char b = (value >> 8) & 0xff;
 return (a << 8) | (b << 0);
 } else if constexpr (::sus::mem::size_of<T>() == 4) {
 unsigned char a = (value >> 0) & 0xff;
 unsigned char b = (value >> 8) & 0xff;
 unsigned char c = (value >> 16) & 0xff;
 unsigned char d = (value >> 24) & 0xff;
 return (a << 24) | (b << 16) | (c << 8) | (d << 0);
 } else if constexpr (::sus::mem::size_of<T>() == 8) {
 unsigned char a = (value >> 0) & 0xff;
 unsigned char b = (value >> 8) & 0xff;
 unsigned char c = (value >> 16) & 0xff;
 unsigned char d = (value >> 24) & 0xff;
 unsigned char e = (value >> 32) & 0xff;
 unsigned char f = (value >> 40) & 0xff;
 unsigned char g = (value >> 48) & 0xff;
 unsigned char h = (value >> 56) & 0xff;
 return (a << 24) | (b << 16) | (c << 8) | (d << 0) | (e << 24) |
 (f << 16) | (g << 8) | (h << 0);
 }
 }

if constexpr (::sus::mem::size_of<T>() == 1) {
 return value;
 } else if constexpr (::sus::mem::size_of<T>() == 2) {
 return __builtin_bswap16(uint16_t{value});
 } else if constexpr (::sus::mem::size_of<T>() == 4) {
 return __builtin_bswap32(value);
 } else {
 static_assert(::sus::mem::size_of<T>() == 8);
 return __builtin_bswap64(value);
 }

}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_unsigned(T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return static_cast<uint8_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return static_cast<uint16_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 4)
 return static_cast<uint32_t>(x);
 else
 return static_cast<uint64_t>(x);
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 4)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_widened(T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return static_cast<uint16_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return static_cast<uint32_t>(x);
 else
 return static_cast<uint64_t>(x);
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 4)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_widened(T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return static_cast<int16_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return static_cast<int32_t>(x);
 else
 return static_cast<int64_t>(x);
}

template <class T>
 requires(std::is_integral_v<T> && std::is_unsigned_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_signed(T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return static_cast<int8_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return static_cast<int16_t>(x);
 else if constexpr (::sus::mem::size_of<T>() == 4)
 return static_cast<int32_t>(x);
 else
 return static_cast<int64_t>(x);
}

template <class T>
 requires(::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr bool sign_bit(T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == 1)
 return (x & (T(1) << 7)) != 0;
 else if constexpr (::sus::mem::size_of<T>() == 2)
 return (x & (T(1) << 15)) != 0;
 else if constexpr (::sus::mem::size_of<T>() == 4)
 return (x & (T(1) << 31)) != 0;
 else
 return (x & (T(1) << 63)) != 0;
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr OverflowOut<T> add_with_overflow(T x,
 T y) noexcept {
 return OverflowOut <T>{
 .overflow = x > max_value<T>() - y,
 .value = unchecked_add(x, y),
 };
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr OverflowOut<T> add_with_overflow(T x,
 T y) noexcept {
 const auto out =
 into_signed(unchecked_add(into_unsigned(x), into_unsigned(y)));
 return OverflowOut <T>{
 .overflow = y >= 0 != out >= x,
 .value = out,
 };
}

template <class T, class U = decltype(into_signed(std::declval<T>()))>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8 &&
 ::sus::mem::size_of<T>() == ::sus::mem::size_of())
__attribute__((const)) inline constexpr OverflowOut<T> add_with_overflow_signed(
 T x, U y) noexcept {
 return OverflowOut <T>{
 .overflow = (y >= 0 && into_unsigned(y) > max_value<T>() - x) ||
 (y < 0 && into_unsigned(-y) > x),
 .value = unchecked_add(x, into_unsigned(y)),
 };
}

template <class T, class U = decltype(into_unsigned(std::declval<T>()))>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8 &&
 ::sus::mem::size_of<T>() == ::sus::mem::size_of())
__attribute__((const)) inline constexpr OverflowOut<T> add_with_overflow_unsigned(
 T x, U y) noexcept {
 const auto out = into_signed(unchecked_add(into_unsigned(x), y));
 return OverflowOut <T>{
 .overflow = static_cast(max_value<T>()) - static_cast(x) < y,
 .value = out,
 };
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr OverflowOut<T> sub_with_overflow(T x,
 T y) noexcept {
 return OverflowOut <T>{
 .overflow = x < unchecked_add(min_value<T>(), y),
 .value = unchecked_sub(x, y),
 };
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr OverflowOut<T> sub_with_overflow(T x,
 T y) noexcept {
 const auto out =
 into_signed(unchecked_sub(into_unsigned(x), into_unsigned(y)));
 return OverflowOut <T>{
 .overflow = y >= 0 != out <= x,
 .value = out,
 };
}

template <class T, class U = decltype(into_unsigned(std::declval<T>()))>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8 &&
 ::sus::mem::size_of<T>() == ::sus::mem::size_of())
__attribute__((const)) inline constexpr OverflowOut<T> sub_with_overflow_unsigned(
 T x, U y) noexcept {
 const auto out = into_signed(unchecked_sub(into_unsigned(x), y));
 return OverflowOut <T>{
 .overflow = static_cast(x) - static_cast(min_value<T>()) < y,
 .value = out,
 };
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr std::make_unsigned_t<T>
sub_with_unsigned_positive_result(T x, T y) noexcept {
 return unchecked_sub(into_unsigned(x), into_unsigned(y));
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 4)
__attribute__((const)) inline constexpr OverflowOut<T> mul_with_overflow(T x,
 T y) noexcept {

auto out = unchecked_mul(into_widened(x), into_widened(y));
 using Wide = decltype(out);
 return OverflowOut <T>{
 .overflow = out > Wide{max_value<T>()}, .value = static_cast<T>(out)};
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() == 8)
__attribute__((const)) inline constexpr OverflowOut<T> mul_with_overflow(T x,
 T y) noexcept {

auto out = __uint128_t{x} * __uint128_t{y};
 return OverflowOut <T>{
 .overflow = out > __uint128_t{max_value<T>()},
 .value = static_cast<T>(out)};

}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 4)
__attribute__((const)) inline constexpr OverflowOut<T> mul_with_overflow(T x,
 T y) noexcept {

auto out = into_widened(x) * into_widened(y);
 using Wide = decltype(out);
 return OverflowOut <T>{
 .overflow = out > Wide{max_value<T>()} || out < Wide{min_value<T>()},
 .value = static_cast<T>(out)};
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() == 8)
__attribute__((const)) inline constexpr OverflowOut<T> mul_with_overflow(T x,
 T y) noexcept {

auto out = __int128_t{x} * __int128_t{y};
 return OverflowOut <T>{
 .overflow =
 out > __int128_t{max_value<T>()} || out < __int128_t{min_value<T>()},
 .value = static_cast<T>(out)};

}

template <class T>
 requires(std::is_integral_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr OverflowOut<T> pow_with_overflow(
 T base, uint32_t exp) noexcept {
 if (exp == 0)
 return OverflowOut <T>{.overflow = false,
 .value = T{1}};
 auto acc = T{1};
 bool overflow = false;
 while (exp > 1) {
 if (exp & 1) {
 auto r = mul_with_overflow(acc, base);
 overflow |= r.overflow;
 acc = r.value;
 }
 exp /= 2;
 auto r = mul_with_overflow(base, base);
 overflow |= r.overflow;
 base = r.value;
 }
 auto r = mul_with_overflow(acc, base);
 return OverflowOut <T>{
 .overflow = overflow || r.overflow, .value = r.value};
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 (::sus::mem::size_of<T>() == 1 || ::sus::mem::size_of<T>() == 2 ||
 ::sus::mem::size_of<T>() == 4 || ::sus::mem::size_of<T>() == 8))
__attribute__((const)) inline constexpr OverflowOut<T> shl_with_overflow(
 T x, uint64_t shift) noexcept {

const bool overflow = shift >= num_bits<T>();
 if (overflow) [[unlikely]]
 shift = shift & (unchecked_sub(num_bits<T>(), uint32_t{1}));
 return OverflowOut <T>{.overflow = overflow,
 .value = unchecked_shl(x, shift)};
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 (::sus::mem::size_of<T>() == 1 || ::sus::mem::size_of<T>() == 2 ||
 ::sus::mem::size_of<T>() == 4 || ::sus::mem::size_of<T>() == 8))
__attribute__((const)) inline constexpr OverflowOut<T> shl_with_overflow(
 T x, uint64_t shift) noexcept {

const bool overflow = shift >= num_bits<T>();
 if (overflow) [[unlikely]]
 shift = shift & (unchecked_sub(num_bits<T>(), uint32_t{1}));
 return OverflowOut <T>{
 .overflow = overflow,
 .value = into_signed(unchecked_shl(into_unsigned(x), shift))};
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 (::sus::mem::size_of<T>() == 1 || ::sus::mem::size_of<T>() == 2 ||
 ::sus::mem::size_of<T>() == 4 || ::sus::mem::size_of<T>() == 8))
__attribute__((const)) inline constexpr OverflowOut<T> shr_with_overflow(
 T x, uint64_t shift) noexcept {

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 (::sus::mem::size_of<T>() == 1 || ::sus::mem::size_of<T>() == 2 ||
 ::sus::mem::size_of<T>() == 4 || ::sus::mem::size_of<T>() == 8))
__attribute__((const)) inline constexpr OverflowOut<T> shr_with_overflow(
 T x, uint64_t shift) noexcept {

const bool overflow = shift >= num_bits<T>();
 if (overflow) [[unlikely]]
 shift = shift & (unchecked_sub(num_bits<T>(), uint32_t{1}));
 return OverflowOut <T>{
 .overflow = overflow,
 .value = into_signed(unchecked_shr(into_unsigned(x), shift))};
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_add(T x, T y) noexcept {

const auto out = add_with_overflow(x, y);
 if (!out.overflow) [[likely]]
 return out.value;
 else
 return max_value<T>();
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_add(T x, T y) noexcept {

if (y >= 0) {
 if (x <= max_value<T>() - y) [[likely]]
 return x + y;
 else
 return max_value<T>();
 } else {
 if (x >= min_value<T>() - y) [[likely]]
 return x + y;
 else
 return min_value<T>();
 }
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_sub(T x, T y) noexcept {

const auto out = sub_with_overflow(x, y);
 if (!out.overflow) [[likely]]
 return out.value;
 else
 return min_value<T>();
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_sub(T x, T y) noexcept {

if (y <= 0) {
 if (x <= max_value<T>() + y) [[likely]]
 return x - y;
 else
 return max_value<T>();
 } else {
 if (x >= min_value<T>() + y) [[likely]]
 return x - y;
 else
 return min_value<T>();
 }
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_mul(T x, T y) noexcept {

const auto out = mul_with_overflow(x, y);
 if (!out.overflow) [[likely]]
 return out.value;
 else
 return max_value<T>();
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T saturating_mul(T x, T y) noexcept {

const auto out = mul_with_overflow(x, y);
 if (!out.overflow) [[likely]]
 return out.value;
 else if (x > 0 == y > 0)
 return max_value<T>();
 else
 return min_value<T>();
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T wrapping_add(T x, T y) noexcept {
 return x + y;
}

return add_with_overflow(x, y).value;
}

return sub_with_overflow(x, y).value;
}

return mul_with_overflow(x, y).value;
}

return pow_with_overflow(base, exp).value;
}

template <class T>
 requires(std::is_integral_v<T> && !std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T one_less_than_next_power_of_two(
 T x) noexcept {
 if (x <= 1u) {
 return 0u;
 } else {
 const auto p = unchecked_sub(x, T{1});

const auto z = leading_zeros_nonzero(::sus::marker::unsafe_fn, p);
 return unchecked_shr(max_value<T>(), z);
 }
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr bool div_overflows(T x, T y) noexcept {

return y == T{0} || ((x == min_value<T>()) & (y == T{-1}));
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr bool div_overflows_nonzero(
 ::sus::marker::UnsafeFnMarker, T x, T y) noexcept {

return ((x == min_value<T>()) & (y == T{-1}));
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T div_euclid(::sus::marker::UnsafeFnMarker, T x,
 T y) noexcept {
 const auto q = unchecked_div(x, y);
 if (x % y >= 0)
 return q;
 else if (y > 0)
 return unchecked_sub(q, T{1});
 else
 return unchecked_add(q, T{1});
}

template <class T>
 requires(std::is_integral_v<T> && std::is_signed_v<T> &&
 ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T rem_euclid(::sus::marker::UnsafeFnMarker, T x,
 T y) noexcept {
 const auto r = unchecked_rem(x, y);
 if (r < 0) {
 if (y < 0)
 return unchecked_sub(r, y);
 else
 return unchecked_add(r, y);
 } else {
 return r;
 }
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_unsigned_integer(
 T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return std::bit_cast<uint32_t>(x);
 else
 return std::bit_cast<uint64_t>(x);
}

template <class T>
 requires(std::is_integral_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr auto into_float_constexpr(
 ::sus::marker::UnsafeFnMarker, T x) noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return std::bit_cast<float>(x);
 else
 return std::bit_cast<double>(x);
}

template <class T>
 requires(std::is_integral_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) auto into_float(T x) noexcept {

return into_float_constexpr(::sus::marker::unsafe_fn, x);
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T min_positive_value() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return 1.17549435E-38f;
 else
 return 0.22250738585072014E-307;
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t min_exp() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return int32_t{-125};
 else
 return int32_t{-1021};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t max_exp() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return int32_t{128};
 else
 return int32_t{1024};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t min_10_exp() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return int32_t{-37};
 else
 return int32_t{-307};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t max_10_exp() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return int32_t{38};
 else
 return int32_t{308};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t radix() noexcept {
 return 2;
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t
num_mantissa_digits() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return uint32_t{24};
 else
 return uint32_t{53};
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t num_digits() noexcept {
 if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return 6;
 else
 return 15;
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T nan() noexcept {

if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return into_float_constexpr(::sus::marker::unsafe_fn, uint32_t{0x7fc00000});
 else
 return into_float_constexpr(::sus::marker::unsafe_fn,
 uint64_t{0x7ff8000000000000});
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T infinity() noexcept {

if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return into_float_constexpr(::sus::marker::unsafe_fn, uint32_t{0x7f800000});
 else
 return into_float_constexpr(::sus::marker::unsafe_fn,
 uint64_t{0x7ff0000000000000});
}

template <class T>
 requires(std::is_floating_point_v<T>)
__attribute__((const)) inline __attribute__((always_inline)) constexpr T negative_infinity() noexcept {

if constexpr (::sus::mem::size_of<T>() == ::sus::mem::size_of<float>())
 return into_float_constexpr(::sus::marker::unsafe_fn, uint32_t{0xff800000});
 else
 return into_float_constexpr(::sus::marker::unsafe_fn,
 uint64_t{0xfff0000000000000});
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t exponent_bits(
 float x) noexcept {
 constexpr uint32_t mask = 0b01111111100000000000000000000000;
 return static_cast<int32_t>(
 unchecked_shr(into_unsigned_integer(x) & mask, 23));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t exponent_bits(
 double x) noexcept {
 constexpr uint64_t mask =
 0b0111111111110000000000000000000000000000000000000000000000000000;
 return static_cast<int32_t>(
 unchecked_shr(into_unsigned_integer(x) & mask, 52));
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t float_normal_exponent_value(
    float x) noexcept {
  return exponent_bits(x) - int32_t{127};
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr int32_t float_normal_exponent_value(
    double x) noexcept {
  return exponent_bits(x) - int32_t{1023};
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint32_t mantissa(float x) noexcept {
  constexpr uint32_t mask = 0b00000000011111111111111111111111;
  return into_unsigned_integer(x) & mask;
}

__attribute__((const)) inline __attribute__((always_inline)) constexpr uint64_t mantissa(
    double x) noexcept {
  constexpr uint64_t mask =
      0b0000000000001111111111111111111111111111111111111111111111111111;
  return into_unsigned_integer(x) & mask;
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr bool float_is_zero(T x) noexcept {
 return (into_unsigned_integer(x) & ~high_bit<T>()) == 0;
}

__attribute__((const)) inline constexpr bool float_is_inf(float x) noexcept {

return __builtin_isinf(x);

}

__attribute__((const)) inline constexpr bool float_is_inf(double x) noexcept {

return __builtin_isinf(x);

}

__attribute__((const)) inline constexpr bool float_is_inf_or_nan(float x) noexcept {
  constexpr auto mask = uint32_t{0x7f800000};
  return (into_unsigned_integer(x) & mask) == mask;
}

__attribute__((const)) inline constexpr bool float_is_inf_or_nan(double x) noexcept {
  constexpr auto mask = uint64_t{0x7ff0000000000000};
  return (into_unsigned_integer(x) & mask) == mask;
}

__attribute__((const)) inline constexpr bool float_is_nan(float x) noexcept {

return __builtin_isnan(x);

}

__attribute__((const)) inline constexpr bool float_is_nan(double x) noexcept {

return __builtin_isnan(x);

}

__attribute__((const)) inline constexpr bool float_is_nan_quiet(float x) noexcept {

constexpr auto quiet_mask = uint32_t{uint32_t{1} << (23 - 1)};
 return (into_unsigned_integer(x) & quiet_mask) != 0;
}

__attribute__((const)) inline constexpr bool float_is_nan_quiet(double x) noexcept {

constexpr auto quiet_mask = uint64_t{uint64_t{1} << (52 - 1)};
 return (into_unsigned_integer(x) & quiet_mask) != 0;
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) constexpr bool float_nonzero_is_subnormal(
 T x) noexcept {
 return exponent_bits(x) == int32_t{0};
}

__attribute__((const)) inline constexpr bool float_is_normal(float x) noexcept {

const auto e = exponent_bits(x);
  return e != 0 && e != int32_t{0b011111111};
}

__attribute__((const)) inline constexpr bool float_is_normal(double x) noexcept {

const auto e = exponent_bits(x);
  return e != 0 && e != int32_t{0b011111111111};
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr T truncate_float(T x) noexcept {
 if (x <= max_int64_float<T>() && x >= min_int64_float<T>())
 return static_cast<T>(static_cast<int64_t>(x));

constexpr auto mantissa_width =
 ::sus::mem::size_of<T>() == ::sus::mem::size_of<float>() ? uint32_t{23}
 : uint32_t{52};

if (float_is_inf_or_nan(x) || float_is_zero(x)) return x;
  if (float_nonzero_is_subnormal(x)) [[unlikely]]
    return T{0};

const int32_t exponent = float_normal_exponent_value(x);

if (exponent >= static_cast<int32_t>(mantissa_width)) return x;

if (exponent <= -1) {
 if ((into_unsigned_integer(x) & high_bit<T>()) != 0)
 return T{-0.0};
 else
 return T{0.0};
 }

const uint32_t trim_bits = mantissa_width - static_cast<uint32_t>(exponent);
 const auto shr = unchecked_shr(into_unsigned_integer(x), trim_bits);
 const auto shl = unchecked_shl(shr, trim_bits);

return into_float_constexpr(::sus::marker::unsafe_fn, shl);
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr bool float_signbit(T x) noexcept {
 return unchecked_and(into_unsigned_integer(x), high_bit<T>()) != 0;
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline T float_signum(T x) noexcept {

if (float_is_nan(x)) [[unlikely]]
 return x;
 const auto signbit = unchecked_and(into_unsigned_integer(x), high_bit<T>());

return into_float_constexpr(
      ::sus::marker::unsafe_fn,
      unchecked_add(into_unsigned_integer(T{1}), signbit));
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline __attribute__((always_inline)) T float_round(T x) noexcept {
 return std::round(x);
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((pure)) inline __attribute__((always_inline)) T float_round_ties_by_mode(T x) noexcept {
 return std::nearbyint(x);
}

template <class I, class T>
 requires(std::is_floating_point_v<T> && std::is_integral_v &&
 std::is_signed_v && ::sus::mem::size_of<T>() <= 8)
__attribute__((pure)) inline __attribute__((always_inline)) I float_round_to(T x) noexcept {
 static_assert(::sus::mem::size_of() <= ::sus::mem::size_of<long long>());

if (float_is_nan(x)) [[unlikely]]
 return I{0};
 if (x > max_int_float<I, T>()) [[unlikely]]
 return max_value();
 if (x < min_int_float<I, T>()) [[unlikely]]
 return min_value();
 if constexpr (::sus::mem::size_of() == ::sus::mem::size_of<long long>()) {
 return std::llrint(x);
 } else {
 return static_cast(std::lrint(x));
 }
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) constexpr inline ::sus::num::FpCategory float_category(
 T x) noexcept {
 constexpr auto nan = 1;
 constexpr auto inf = 2;
 constexpr auto norm = 3;
 constexpr auto subnorm = 4;
 constexpr auto zero = 5;
 switch (__builtin_fpclassify(nan, inf, norm, subnorm, zero, x)) {
 case nan: return ::sus::num::FpCategory::Nan;
 case inf: return ::sus::num::FpCategory::Infinite;
 case norm: return ::sus::num::FpCategory::Normal;
 case subnorm: return ::sus::num::FpCategory::Subnormal;
 case zero: return ::sus::num::FpCategory::Zero;
 default: ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) constexpr inline T float_clamp(T x, T min, T max) noexcept {
 if (float_is_nan(x)) [[unlikely]]
 return nan<T>();
 else if (x < min)
 return min;
 else if (x > max)
 return max;
 return x;
}

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline T next_toward(T from, T to) {
 if constexpr (::sus::mem::size_of<T>() == 4u)
 return std::nexttowardf(from, to);
 else
 return std::nexttoward(from, to);
}

#pragma warning(push)

#pragma warning(disable : 4756)

template <class Out, class T>
 requires(std::is_integral_v<T> && std::is_floating_point_v<Out> &&
 (::sus::mem::size_of<T>() <= 8) &&
 (::sus::mem::size_of<Out>() == 4 || ::sus::mem::size_of<Out>() == 8))
__attribute__((const)) constexpr inline Out static_cast_int_to_float(T x) noexcept {

return static_cast<Out>(x);
}

template <class Out, class T>
 requires(std::is_floating_point_v<T> && std::is_floating_point_v<Out> &&
 ::sus::mem::size_of<T>() == 8 && ::sus::mem::size_of<Out>() == 4)
__attribute__((const)) constexpr inline Out static_cast_to_smaller_float(T x) noexcept {
 if (x <= T{max_value<Out>()} && x >= T{min_value<Out>()}) [[likely]] {

return static_cast<Out>(x);
 }
 if (x > T{max_value<Out>()}) {
 return infinity<Out>();
 }
 if (x < T{min_value<Out>()}) {
 return negative_infinity<Out>();
 }
 return nan<Out>();
}

#pragma warning(pop)

}

namespace sus::num::__private {

template <unsigned int bytes = ::sus::mem::size_of<void*>()>
struct ptr_type;

template <>
struct ptr_type<4> {
 using unsigned_type = uint32_t;
 using signed_type = int32_t;
 using pointer_sized_type = u32;
};

template <>
struct ptr_type<8> {
 using unsigned_type = uint64_t;
 using signed_type = int64_t;
 using pointer_sized_type = u64;
};

template <unsigned int bytes = ::sus::mem::size_of<size_t>()>
struct addr_type;

template <>
struct addr_type<4> {
 using unsigned_type = uint32_t;
 using signed_type = int32_t;
};

template <>
struct addr_type<8> {
 using unsigned_type = uint64_t;
 using signed_type = int64_t;
};

}

namespace sus::num {

template <class T>
concept Float =
 std::same_as<f32, T> || std::same_as<f64, T>;

template <class T>
concept PrimitiveFloat = std::same_as<float, T> || std::same_as<double, T> ||
 std::same_as<long double, T>;

}

namespace sus::num {

template <class T>
concept UnsignedNumeric =
 std::same_as<u8, T> || std::same_as<u16, T> || std::same_as<u32, T> ||
 std::same_as<u64, T> || std::same_as<usize, T>;

template <class T>
concept UnsignedPointer = std::same_as<uptr, T>;

template <class T>
concept Unsigned = UnsignedNumeric<T> || UnsignedPointer<T>;

template <class T>
concept Signed =
 std::same_as<i8, T> || std::same_as<i16, T> || std::same_as<i32, T> ||
 std::same_as<i64, T> || std::same_as<isize, T>;

template <class T>
concept IntegerNumeric = UnsignedNumeric<T> || Signed<T>;

template <class T>
concept IntegerPointer = UnsignedPointer<T>;

template <class T>
concept Integer = IntegerNumeric<T> || IntegerPointer<T>;

template <class T>
concept UnsignedPrimitiveInteger =
 std::same_as<size_t, T> || std::same_as<uintptr_t, T> ||
 std::same_as<bool, T> ||
 (std::is_unsigned_v<char> && std::same_as<char, T>) ||

std::same_as<unsigned char, T> || std::same_as<unsigned short, T> ||
 std::same_as<unsigned int, T> || std::same_as<unsigned long, T> ||
 std::same_as<unsigned long long, T>;

template <class T>
concept SignedPrimitiveInteger =
 (!std::is_unsigned_v<char> && std::same_as<char, T>) ||
 std::same_as<signed char, T> || std::same_as<short, T> ||
 std::same_as<int, T> || std::same_as<long, T> || std::same_as<long long, T>;

template <class T>
concept PrimitiveInteger =
 UnsignedPrimitiveInteger<T> || SignedPrimitiveInteger<T>;

template <class T>
concept UnsignedPrimitiveEnum =
 std::is_enum_v<T> && UnsignedPrimitiveInteger<std::underlying_type_t<T>> &&
 std::is_convertible_v<T, std::underlying_type_t<T>>;

template <class T>
concept SignedPrimitiveEnum =
 std::is_enum_v<T> && SignedPrimitiveInteger<std::underlying_type_t<T>> &&
 std::is_convertible_v<T, std::underlying_type_t<T>>;

template <class T>
concept PrimitiveEnum = UnsignedPrimitiveEnum<T> || SignedPrimitiveEnum<T>;

template <class T>
concept UnsignedPrimitiveEnumClass =
 !UnsignedPrimitiveEnum<T> && std::is_enum_v<T> &&
 UnsignedPrimitiveInteger<std::underlying_type_t<T>>;

template <class T>
concept SignedPrimitiveEnumClass =
 !SignedPrimitiveEnum<T> && std::is_enum_v<T> &&
 SignedPrimitiveInteger<std::underlying_type_t<T>>;

template <class T>
concept PrimitiveEnumClass =
 UnsignedPrimitiveEnumClass<T> || SignedPrimitiveEnumClass<T>;

}

namespace sus::num {

class TryFromIntError {
 public:

enum class Kind {
    OutOfBounds,
  };

constexpr static TryFromIntError with_out_of_bounds() noexcept;

__attribute__((pure)) constexpr Kind kind() const noexcept;

__attribute__((pure)) constexpr bool operator==(TryFromIntError rhs) const noexcept;

private:
  enum Construct { CONSTRUCT };
  constexpr explicit TryFromIntError(Construct, Kind k) noexcept;

Kind kind_;
};

}

namespace sus::num {

struct [[clang::trivial_abi]] u32 final {

uint32_t primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value<uint32_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<uint32_t>();

static const u32 MIN;

static const u32 MAX;

static const u32 BITS;

constexpr inline u32() noexcept = default;

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
explicit constexpr inline u32(P v) noexcept
 : primitive_value(static_cast<uint32_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32& operator=(U v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
constexpr inline u32& operator=(P v) noexcept {
 primitive_value = static_cast<uint32_t>(v);
 return *this;
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
__attribute__((pure)) static constexpr u32 from(U u) noexcept {
 return u32(static_cast<uint32_t>(u.primitive_value));
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
__attribute__((pure)) static constexpr u32 from(U u) noexcept {
 return u32(static_cast<uint32_t>(u));
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class U>
 requires((UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
__attribute__((pure)) static constexpr u32 from(U u) noexcept {
 return u32(static_cast<std::underlying_type_t>(u));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<u32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

static constexpr u32 from_product(
 ::sus::iter::Iterator<u32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u32(uint32_t{1u});
 for (u32 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr u32 from_sum(::sus::iter::Iterator<u32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u32(uint32_t{0u});
 for (u32 i : ::sus::move(it)) p += i;
 return p;
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<uint32_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr uint32_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const uint32_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const uint32_t* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u32 l, u32 r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u32 l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u32 l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u32 l, u32 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u32 l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u32 l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline u32 operator~() const& noexcept {
  return u32(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator+(
    u32 l, u32 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u32(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator+(
 u32 l, U r) noexcept {
 return l + u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator+(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
friend constexpr inline u32 operator+(u32 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator-(
    u32 l, u32 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u32(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator-(
 u32 l, U r) noexcept {
 return l - u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator-(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) - r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator*(
    u32 l, u32 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u32(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator*(
 u32 l, U r) noexcept {
 return l * u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator*(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) * r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator/(
    u32 l, u32 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u32(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator/(
 u32 l, U r) noexcept {
 return l / u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator/(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) / r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator%(
    u32 l, u32 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u32(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator%(
 u32 l, U r) noexcept {
 return l % u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator%(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) % r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator&(
    u32 l, u32 r) noexcept {
  return u32(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator&(
 u32 l, U r) noexcept {
 return l & u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator&(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) & r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator|(
    u32 l, u32 r) noexcept {
  return u32(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator|(
 u32 l, U r) noexcept {
 return l | u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator|(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) | r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator^(
    u32 l, u32 r) noexcept {
  return u32(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator^(
 u32 l, U r) noexcept {
 return l ^ u32(static_cast<uint32_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint32_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u32 operator^(
 U l, u32 r) noexcept {
 return u32(static_cast<uint32_t>(l)) ^ r;
}

constexpr inline void operator+=(u32 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(u32 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(u32 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(u32 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(u32 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(u32 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(u32 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(u32 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint32_t>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint32_t>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr u32 abs_diff(u32 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return u32(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return u32(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_add(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_add_signed(
 i32 rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<u32, bool> overflowing_add(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_add_signed(
 i32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 saturating_add(u32 rhs) const& noexcept {
  return u32(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 saturating_add_signed(i32 rhs) const& noexcept;

__attribute__((pure)) inline constexpr u32 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              u32 rhs) const& noexcept {
  return u32(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 wrapping_add(u32 rhs) const& noexcept {
  return u32(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 wrapping_add_signed(i32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_div(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_div(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 saturating_div(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 wrapping_div(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_mul(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_mul(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 saturating_mul(u32 rhs) const& noexcept {
  return u32(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       u32 rhs) const& noexcept {
  return u32(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 wrapping_mul(u32 rhs) const& noexcept {
  return u32(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_neg() const& noexcept {
  return (u32(uint32_t{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_rem(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_rem(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_rem(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 div_euclid(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_div_euclid(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_div_euclid(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_div_euclid(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 rem_euclid(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_rem_euclid(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_rem_euclid(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_rem_euclid(u32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u32(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_shl(u32 rhs) const& noexcept {
  return u32(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_shr(u32 rhs) const& noexcept {
  return u32(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_sub(u32 rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_sub(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u32 saturating_sub(u32 rhs) const& {
  return u32(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       u32 rhs) const& noexcept {
  return u32(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 wrapping_sub(u32 rhs) const& noexcept {
  return u32(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 reverse_bits() const& noexcept {
  return u32(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr u32 rotate_left(u32 n) const& noexcept {
  return u32(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u32 rotate_right(u32 n) const& noexcept {
  return u32(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u32 swap_bytes() const& noexcept {
  return u32(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr u32 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return u32(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u32, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_pow(u32 exp) const& noexcept {
  return u32(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 u32 base) const& noexcept;

__attribute__((pure)) constexpr u32 log(u32 base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
  return count_ones() == u32(uint32_t{1u});
}

__attribute__((pure)) constexpr u32 next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u32(one_less) + u32(uint32_t{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr u32 wrapping_next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u32(one_less).wrapping_add(u32(uint32_t{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr u32 from_be(const u32& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr u32 from_le(const u32& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr u32 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr u32 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint32_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint32_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint32_t>()>
to_ne_bytes() const& noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u32 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint32_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u32 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint32_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u32 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint32_t>()>&
 bytes) noexcept;

};

inline constexpr u32 u32::MIN = u32(u32::MIN_PRIMITIVE);

inline constexpr u32 u32::MAX = u32(u32::MAX_PRIMITIVE);

inline constexpr u32 u32::BITS = u32(__private::num_bits<uint32_t>());

struct [[clang::trivial_abi]] u8 final {

uint8_t primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value<uint8_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<uint8_t>();

static const u8 MIN;

static const u8 MAX;

static const u32 BITS;

constexpr inline u8() noexcept = default;

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
explicit constexpr inline u8(P v) noexcept
 : primitive_value(static_cast<uint8_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8& operator=(U v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
constexpr inline u8& operator=(P v) noexcept {
 primitive_value = static_cast<uint8_t>(v);
 return *this;
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
__attribute__((pure)) static constexpr u8 from(U u) noexcept {
 return u8(static_cast<uint8_t>(u.primitive_value));
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
__attribute__((pure)) static constexpr u8 from(U u) noexcept {
 return u8(static_cast<uint8_t>(u));
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class U>
 requires((UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
__attribute__((pure)) static constexpr u8 from(U u) noexcept {
 return u8(static_cast<std::underlying_type_t>(u));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<u8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

static constexpr u8 from_product(
 ::sus::iter::Iterator<u8> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u8(uint8_t{1u});
 for (u8 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr u8 from_sum(::sus::iter::Iterator<u8> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u8(uint8_t{0u});
 for (u8 i : ::sus::move(it)) p += i;
 return p;
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<uint8_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr uint8_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const uint8_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const uint8_t* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u8 l, u8 r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u8 l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u8 l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u8 l, u8 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u8 l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u8 l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline u8 operator~() const& noexcept {
  return u8(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator+(
    u8 l, u8 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u8(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator+(
 u8 l, U r) noexcept {
 return l + u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator+(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator+(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator+(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator-(
    u8 l, u8 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u8(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator-(
 u8 l, U r) noexcept {
 return l - u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator-(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator-(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator-(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator*(
    u8 l, u8 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u8(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator*(
 u8 l, U r) noexcept {
 return l * u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator*(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator*(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator*(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator/(
    u8 l, u8 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u8(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator/(
 u8 l, U r) noexcept {
 return l / u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator/(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator/(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator/(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator%(
    u8 l, u8 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u8(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator%(
 u8 l, U r) noexcept {
 return l % u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator%(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator%(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator%(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator&(
    u8 l, u8 r) noexcept {
  return u8(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator&(
 u8 l, U r) noexcept {
 return l & u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator&(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator&(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator&(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator|(
    u8 l, u8 r) noexcept {
  return u8(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator|(
 u8 l, U r) noexcept {
 return l | u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator|(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator|(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator|(U l, u8 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator^(
    u8 l, u8 r) noexcept {
  return u8(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator^(
 u8 l, U r) noexcept {
 return l ^ u8(static_cast<uint8_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u8 operator^(
 U l, u8 r) noexcept {
 return u8(static_cast<uint8_t>(l)) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator^(u8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint8_t>()))
friend constexpr inline u8 operator^(U l, u8 r) noexcept = delete;

constexpr inline void operator+=(u8 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(u8 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(u8 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(u8 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(u8 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(u8 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(u8 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(u8 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint8_t>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint8_t>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr u8 abs_diff(u8 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return u8(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return u8(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_add(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_add_signed(
 i8 rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<u8, bool> overflowing_add(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_add_signed(
 i8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 saturating_add(u8 rhs) const& noexcept {
  return u8(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 saturating_add_signed(i8 rhs) const& noexcept;

__attribute__((pure)) inline constexpr u8 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              u8 rhs) const& noexcept {
  return u8(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 wrapping_add(u8 rhs) const& noexcept {
  return u8(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 wrapping_add_signed(i8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_div(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_div(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 saturating_div(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 wrapping_div(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_mul(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_mul(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 saturating_mul(u8 rhs) const& noexcept {
  return u8(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       u8 rhs) const& noexcept {
  return u8(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 wrapping_mul(u8 rhs) const& noexcept {
  return u8(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_neg() const& noexcept {
  return (u8(uint8_t{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_rem(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_rem(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_rem(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 div_euclid(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_div_euclid(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_div_euclid(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_div_euclid(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 rem_euclid(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_rem_euclid(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_rem_euclid(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_rem_euclid(u8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u8(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_shl(u32 rhs) const& noexcept {
  return u8(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_shr(u32 rhs) const& noexcept {
  return u8(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_sub(u8 rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_sub(
 u8 rhs) const& noexcept;

__attribute__((pure)) constexpr u8 saturating_sub(u8 rhs) const& {
  return u8(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       u8 rhs) const& noexcept {
  return u8(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u8 wrapping_sub(u8 rhs) const& noexcept {
  return u8(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr u8 reverse_bits() const& noexcept {
  return u8(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr u8 rotate_left(u32 n) const& noexcept {
  return u8(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u8 rotate_right(u32 n) const& noexcept {
  return u8(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u8 swap_bytes() const& noexcept {
  return u8(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr u8 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return u8(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u8, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_pow(u32 exp) const& noexcept {
  return u8(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 u8 base) const& noexcept;

__attribute__((pure)) constexpr u32 log(u8 base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
  return count_ones() == u8(uint8_t{1u});
}

__attribute__((pure)) constexpr u8 next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u8(one_less) + u8(uint8_t{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<u8> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr u8 wrapping_next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u8(one_less).wrapping_add(u8(uint8_t{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr u8 from_be(const u8& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr u8 from_le(const u8& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr u8 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr u8 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint8_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint8_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint8_t>()>
to_ne_bytes() const& noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u8 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint8_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u8 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint8_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u8 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint8_t>()>&
 bytes) noexcept;

};

inline constexpr u8 u8::MIN = u8(u8::MIN_PRIMITIVE);

inline constexpr u8 u8::MAX = u8(u8::MAX_PRIMITIVE);

inline constexpr u32 u8::BITS = u32(__private::num_bits<uint8_t>());

struct [[clang::trivial_abi]] u16 final {

uint16_t primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value<uint16_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<uint16_t>();

static const u16 MIN;

static const u16 MAX;

static const u32 BITS;

constexpr inline u16() noexcept = default;

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
explicit constexpr inline u16(P v) noexcept
 : primitive_value(static_cast<uint16_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16& operator=(U v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
constexpr inline u16& operator=(P v) noexcept {
 primitive_value = static_cast<uint16_t>(v);
 return *this;
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
__attribute__((pure)) static constexpr u16 from(U u) noexcept {
 return u16(static_cast<uint16_t>(u.primitive_value));
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
__attribute__((pure)) static constexpr u16 from(U u) noexcept {
 return u16(static_cast<uint16_t>(u));
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class U>
 requires((UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
__attribute__((pure)) static constexpr u16 from(U u) noexcept {
 return u16(static_cast<std::underlying_type_t>(u));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<u16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

static constexpr u16 from_product(
 ::sus::iter::Iterator<u16> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u16(uint16_t{1u});
 for (u16 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr u16 from_sum(::sus::iter::Iterator<u16> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u16(uint16_t{0u});
 for (u16 i : ::sus::move(it)) p += i;
 return p;
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<uint16_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr uint16_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const uint16_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const uint16_t* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u16 l, u16 r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u16 l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u16 l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u16 l, u16 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u16 l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u16 l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline u16 operator~() const& noexcept {
  return u16(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator+(
    u16 l, u16 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u16(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator+(
 u16 l, U r) noexcept {
 return l + u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator+(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator+(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator+(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator-(
    u16 l, u16 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u16(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator-(
 u16 l, U r) noexcept {
 return l - u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator-(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator-(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator-(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator*(
    u16 l, u16 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u16(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator*(
 u16 l, U r) noexcept {
 return l * u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator*(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator*(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator*(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator/(
    u16 l, u16 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u16(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator/(
 u16 l, U r) noexcept {
 return l / u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator/(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator/(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator/(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator%(
    u16 l, u16 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u16(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator%(
 u16 l, U r) noexcept {
 return l % u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator%(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator%(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator%(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator&(
    u16 l, u16 r) noexcept {
  return u16(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator&(
 u16 l, U r) noexcept {
 return l & u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator&(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator&(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator&(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator|(
    u16 l, u16 r) noexcept {
  return u16(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator|(
 u16 l, U r) noexcept {
 return l | u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator|(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator|(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator|(U l, u16 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator^(
    u16 l, u16 r) noexcept {
  return u16(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator^(
 u16 l, U r) noexcept {
 return l ^ u16(static_cast<uint16_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u16 operator^(
 U l, u16 r) noexcept {
 return u16(static_cast<uint16_t>(l)) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator^(u16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint16_t>()))
friend constexpr inline u16 operator^(U l, u16 r) noexcept = delete;

constexpr inline void operator+=(u16 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(u16 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(u16 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(u16 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(u16 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(u16 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(u16 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(u16 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint16_t>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint16_t>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr u16 abs_diff(u16 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return u16(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return u16(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_add(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_add_signed(
 i16 rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<u16, bool> overflowing_add(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_add_signed(
 i16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 saturating_add(u16 rhs) const& noexcept {
  return u16(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 saturating_add_signed(i16 rhs) const& noexcept;

__attribute__((pure)) inline constexpr u16 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              u16 rhs) const& noexcept {
  return u16(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 wrapping_add(u16 rhs) const& noexcept {
  return u16(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 wrapping_add_signed(i16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_div(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_div(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 saturating_div(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 wrapping_div(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_mul(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_mul(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 saturating_mul(u16 rhs) const& noexcept {
  return u16(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       u16 rhs) const& noexcept {
  return u16(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 wrapping_mul(u16 rhs) const& noexcept {
  return u16(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_neg() const& noexcept {
  return (u16(uint16_t{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_rem(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_rem(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_rem(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 div_euclid(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_div_euclid(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_div_euclid(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_div_euclid(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 rem_euclid(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_rem_euclid(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_rem_euclid(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_rem_euclid(u16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u16(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_shl(u32 rhs) const& noexcept {
  return u16(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_shr(u32 rhs) const& noexcept {
  return u16(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_sub(u16 rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_sub(
 u16 rhs) const& noexcept;

__attribute__((pure)) constexpr u16 saturating_sub(u16 rhs) const& {
  return u16(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       u16 rhs) const& noexcept {
  return u16(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u16 wrapping_sub(u16 rhs) const& noexcept {
  return u16(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr u16 reverse_bits() const& noexcept {
  return u16(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr u16 rotate_left(u32 n) const& noexcept {
  return u16(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u16 rotate_right(u32 n) const& noexcept {
  return u16(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u16 swap_bytes() const& noexcept {
  return u16(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr u16 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return u16(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u16, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_pow(u32 exp) const& noexcept {
  return u16(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 u16 base) const& noexcept;

__attribute__((pure)) constexpr u32 log(u16 base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
  return count_ones() == u16(uint16_t{1u});
}

__attribute__((pure)) constexpr u16 next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u16(one_less) + u16(uint16_t{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<u16> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr u16 wrapping_next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u16(one_less).wrapping_add(u16(uint16_t{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr u16 from_be(const u16& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr u16 from_le(const u16& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr u16 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr u16 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint16_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint16_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint16_t>()>
to_ne_bytes() const& noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u16 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint16_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u16 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint16_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u16 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint16_t>()>&
 bytes) noexcept;

};

inline constexpr u16 u16::MIN = u16(u16::MIN_PRIMITIVE);

inline constexpr u16 u16::MAX = u16(u16::MAX_PRIMITIVE);

inline constexpr u32 u16::BITS = u32(__private::num_bits<uint16_t>());

struct [[clang::trivial_abi]] u64 final {

uint64_t primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value<uint64_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<uint64_t>();

static const u64 MIN;

static const u64 MAX;

static const u32 BITS;

constexpr inline u64() noexcept = default;

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
explicit constexpr inline u64(P v) noexcept
 : primitive_value(static_cast<uint64_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64& operator=(U v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
constexpr inline u64& operator=(P v) noexcept {
 primitive_value = static_cast<uint64_t>(v);
 return *this;
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
__attribute__((pure)) static constexpr u64 from(U u) noexcept {
 return u64(static_cast<uint64_t>(u.primitive_value));
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
__attribute__((pure)) static constexpr u64 from(U u) noexcept {
 return u64(static_cast<uint64_t>(u));
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class U>
 requires((UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
__attribute__((pure)) static constexpr u64 from(U u) noexcept {
 return u64(static_cast<std::underlying_type_t>(u));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<u64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

static constexpr u64 from_product(
 ::sus::iter::Iterator<u64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u64(uint64_t{1u});
 for (u64 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr u64 from_sum(::sus::iter::Iterator<u64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = u64(uint64_t{0u});
 for (u64 i : ::sus::move(it)) p += i;
 return p;
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<uint64_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr uint64_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const uint64_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const uint64_t* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u64 l, u64 r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u64 l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    u64 l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u64 l, u64 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u64 l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(u64 l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline u64 operator~() const& noexcept {
  return u64(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator+(
    u64 l, u64 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u64(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator+(
 u64 l, U r) noexcept {
 return l + u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>())
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator+(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator+(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator+(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator-(
    u64 l, u64 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u64(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator-(
 u64 l, U r) noexcept {
 return l - u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator-(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator-(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator-(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator*(
    u64 l, u64 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return u64(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator*(
 u64 l, U r) noexcept {
 return l * u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator*(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator*(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator*(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator/(
    u64 l, u64 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u64(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator/(
 u64 l, U r) noexcept {
 return l / u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator/(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator/(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator/(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator%(
    u64 l, u64 r) noexcept {

::sus::check(r.primitive_value != 0u);
  return u64(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator%(
 u64 l, U r) noexcept {
 return l % u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator%(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator%(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator%(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator&(
    u64 l, u64 r) noexcept {
  return u64(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator&(
 u64 l, U r) noexcept {
 return l & u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator&(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator&(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator&(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator|(
    u64 l, u64 r) noexcept {
  return u64(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator|(
 u64 l, U r) noexcept {
 return l | u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator|(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator|(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator|(U l, u64 r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator^(
    u64 l, u64 r) noexcept {
  return u64(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator^(
 u64 l, U r) noexcept {
 return l ^ u64(static_cast<uint64_t>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline u64 operator^(
 U l, u64 r) noexcept {
 return u64(static_cast<uint64_t>(l)) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator^(u64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of<uint64_t>()))
friend constexpr inline u64 operator^(U l, u64 r) noexcept = delete;

constexpr inline void operator+=(u64 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(u64 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(u64 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(u64 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(u64 r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(u64 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(u64 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(u64 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint64_t>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits<uint64_t>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr u64 abs_diff(u64 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return u64(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return u64(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_add(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_add_signed(
 i64 rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<u64, bool> overflowing_add(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_add_signed(
 i64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 saturating_add(u64 rhs) const& noexcept {
  return u64(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 saturating_add_signed(i64 rhs) const& noexcept;

__attribute__((pure)) inline constexpr u64 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              u64 rhs) const& noexcept {
  return u64(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 wrapping_add(u64 rhs) const& noexcept {
  return u64(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 wrapping_add_signed(i64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_div(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_div(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 saturating_div(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 wrapping_div(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_mul(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_mul(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 saturating_mul(u64 rhs) const& noexcept {
  return u64(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       u64 rhs) const& noexcept {
  return u64(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 wrapping_mul(u64 rhs) const& noexcept {
  return u64(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_neg() const& noexcept {
  return (u64(uint64_t{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_rem(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_rem(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_rem(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 div_euclid(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_div_euclid(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_div_euclid(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_div_euclid(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 rem_euclid(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_rem_euclid(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_rem_euclid(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_rem_euclid(u64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return u64(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_shl(u32 rhs) const& noexcept {
  return u64(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_shr(u32 rhs) const& noexcept {
  return u64(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_sub(u64 rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_sub(
 u64 rhs) const& noexcept;

__attribute__((pure)) constexpr u64 saturating_sub(u64 rhs) const& {
  return u64(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       u64 rhs) const& noexcept {
  return u64(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u64 wrapping_sub(u64 rhs) const& noexcept {
  return u64(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr u64 reverse_bits() const& noexcept {
  return u64(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr u64 rotate_left(u32 n) const& noexcept {
  return u64(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u64 rotate_right(u32 n) const& noexcept {
  return u64(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr u64 swap_bytes() const& noexcept {
  return u64(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr u64 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return u64(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<u64, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_pow(u32 exp) const& noexcept {
  return u64(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 u64 base) const& noexcept;

__attribute__((pure)) constexpr u32 log(u64 base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
  return count_ones() == u64(uint64_t{1u});
}

__attribute__((pure)) constexpr u64 next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u64(one_less) + u64(uint64_t{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<u64> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr u64 wrapping_next_power_of_two() const& noexcept {
  const auto one_less =
      __private::one_less_than_next_power_of_two(primitive_value);
  return u64(one_less).wrapping_add(u64(uint64_t{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr u64 from_be(const u64& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr u64 from_le(const u64& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr u64 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr u64 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint64_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint64_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<uint64_t>()>
to_ne_bytes() const& noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u64 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint64_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u64 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint64_t>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr u64 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<uint64_t>()>&
 bytes) noexcept;

};

inline constexpr u64 u64::MIN = u64(u64::MIN_PRIMITIVE);

inline constexpr u64 u64::MAX = u64(u64::MAX_PRIMITIVE);

inline constexpr u32 u64::BITS = u32(__private::num_bits<uint64_t>());

struct [[clang::trivial_abi]] usize final {

::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>();

static constexpr auto MAX_PRIMITIVE = __private::max_value< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>();

static const usize MIN;

static const usize MAX;

static const u32 BITS;

constexpr inline usize() noexcept = default;

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
constexpr inline usize(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
explicit constexpr inline usize(P v) noexcept
 : primitive_value(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
constexpr inline usize& operator=(U v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
constexpr inline usize& operator=(P v) noexcept {
 primitive_value = static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(v);
 return *this;
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
__attribute__((pure)) static constexpr usize from(U u) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(u.primitive_value));
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
__attribute__((pure)) static constexpr usize from(U u) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(u));
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept;

template <class U>
 requires((UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
__attribute__((pure)) static constexpr usize from(U u) noexcept {
 return usize(static_cast<std::underlying_type_t>(u));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<usize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept;

static constexpr usize from_product(
 ::sus::iter::Iterator<usize> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{1u});
 for (usize i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr usize from_sum(::sus::iter::Iterator<usize> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{0u});
 for (usize i : ::sus::move(it)) p += i;
 return p;
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type* as_mut_ptr() & noexcept {
 return &primitive_value;
}

__attribute__((pure)) constexpr const ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type* as_ptr() const& noexcept {
 return &primitive_value;
}
__attribute__((pure)) constexpr const ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    usize l, usize r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    usize l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    usize l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(usize l, usize r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(usize l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(usize l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline usize operator~() const& noexcept {
  return usize(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator+(
    usize l, usize r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return usize(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator+(
 usize l, U r) noexcept {
 return l + usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator+(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator+(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator+(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator-(
    usize l, usize r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return usize(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator-(
 usize l, U r) noexcept {
 return l - usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator-(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator-(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator-(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator*(
    usize l, usize r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return usize(out.value);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator*(
 usize l, U r) noexcept {
 return l * usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator*(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator*(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator*(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator/(
    usize l, usize r) noexcept {

::sus::check(r.primitive_value != 0u);
  return usize(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator/(
 usize l, U r) noexcept {
 return l / usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator/(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator/(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator/(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator%(
    usize l, usize r) noexcept {

::sus::check(r.primitive_value != 0u);
  return usize(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator%(
 usize l, U r) noexcept {
 return l % usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator%(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator%(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator%(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator&(
    usize l, usize r) noexcept {
  return usize(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator&(
 usize l, U r) noexcept {
 return l & usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator&(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator&(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator&(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator|(
    usize l, usize r) noexcept {
  return usize(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator|(
 usize l, U r) noexcept {
 return l | usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator|(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator|(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator|(U l, usize r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator^(
    usize l, usize r) noexcept {
  return usize(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator^(
 usize l, U r) noexcept {
 return l ^ usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline usize operator^(
 U l, usize r) noexcept {
 return usize(static_cast< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>(l)) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator^(usize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()))
friend constexpr inline usize operator^(U l, usize r) noexcept = delete;

constexpr inline void operator+=(usize r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(usize r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(usize r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(usize r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(usize r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(usize r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(usize r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(usize r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr usize abs_diff(usize other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return usize(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return usize(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_add(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_add_signed(
 isize rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<usize, bool> overflowing_add(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_add_signed(
 isize rhs) const& noexcept;

__attribute__((pure)) constexpr usize saturating_add(usize rhs) const& noexcept {
  return usize(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize saturating_add_signed(isize rhs) const& noexcept;

__attribute__((pure)) inline constexpr usize unchecked_add(::sus::marker::UnsafeFnMarker,
                                              usize rhs) const& noexcept {
  return usize(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize wrapping_add(usize rhs) const& noexcept {
  return usize(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize wrapping_add_signed(isize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_div(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_div(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize saturating_div(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize wrapping_div(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_mul(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_mul(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize saturating_mul(usize rhs) const& noexcept {
  return usize(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       usize rhs) const& noexcept {
  return usize(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize wrapping_mul(usize rhs) const& noexcept {
  return usize(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr usize wrapping_neg() const& noexcept {
 return (usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_rem(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_rem(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_rem(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize div_euclid(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_div_euclid(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_div_euclid(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_div_euclid(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize rem_euclid(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_rem_euclid(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_rem_euclid(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_rem_euclid(usize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return usize(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_shl(u32 rhs) const& noexcept {
  return usize(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_shr(u32 rhs) const& noexcept {
  return usize(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_sub(usize rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_sub(
 usize rhs) const& noexcept;

__attribute__((pure)) constexpr usize saturating_sub(usize rhs) const& {
  return usize(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       usize rhs) const& noexcept {
  return usize(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr usize wrapping_sub(usize rhs) const& noexcept {
  return usize(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr usize reverse_bits() const& noexcept {
  return usize(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr usize rotate_left(u32 n) const& noexcept {
  return usize(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr usize rotate_right(u32 n) const& noexcept {
  return usize(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr usize swap_bytes() const& noexcept {
  return usize(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr usize pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return usize(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<usize, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr usize wrapping_pow(u32 exp) const& noexcept {
  return usize(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 usize base) const& noexcept;

__attribute__((pure)) constexpr u32 log(usize base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
 return count_ones() == usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{1u});
}

__attribute__((pure)) constexpr usize next_power_of_two() const& noexcept {
 const auto one_less =
 __private::one_less_than_next_power_of_two(primitive_value);
 return usize(one_less) + usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<usize> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr usize wrapping_next_power_of_two() const& noexcept {
 const auto one_less =
 __private::one_less_than_next_power_of_two(primitive_value);
 return usize(one_less).wrapping_add(usize(::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr usize from_be(const usize& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr usize from_le(const usize& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr usize to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr usize to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr usize from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr usize from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr usize from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>()>&
 bytes) noexcept;

};

inline constexpr usize usize::MIN = usize(usize::MIN_PRIMITIVE);

inline constexpr usize usize::MAX = usize(usize::MAX_PRIMITIVE);

inline constexpr u32 usize::BITS = u32(__private::num_bits< ::sus::num::__private::ptr_type<::sus::mem::size_of<size_t>()>::unsigned_type>());

struct [[clang::trivial_abi]] uptr final {

::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type primitive_value{0u};

static constexpr auto MIN_PRIMITIVE = __private::min_value< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>();

static constexpr auto MAX_PRIMITIVE = __private::max_value< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>();

static const uptr MIN;

static const uptr MAX_ADDR;

static const uptr MAX_BIT_PATTERN;

static const u32 BITS;

constexpr inline uptr() noexcept = default;

template <class T>
explicit uptr(T* v) noexcept
 : primitive_value(reinterpret_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(v)) {}

explicit constexpr uptr(std::same_as<std::nullptr_t> auto) noexcept
 : primitive_value(0u) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() == ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
explicit constexpr inline uptr(P v) noexcept : primitive_value(v) {}

template <class T>
uptr& operator=(T* v) noexcept {
 primitive_value = reinterpret_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(v);
 return *this;
}

constexpr uptr& operator=(std::same_as<std::nullptr_t> auto) noexcept {
 primitive_value = 0u;
 return *this;
}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() == ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
constexpr inline uptr& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

uptr with_addr(usize addr) const& noexcept {
 ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type p = ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{addr};
 if constexpr (::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>() !=
 ::sus::mem::size_of<usize>()) {
 constexpr ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type mask =
 uptr::MAX_PRIMITIVE - ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{usize::MAX_PRIMITIVE};
 p |= mask & primitive_value;
 }
 return uptr(p);
}

template <class U>
__attribute__((pure)) static uptr from(U* u) noexcept {
 return uptr(reinterpret_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(u));
}

template <class U>
__attribute__((pure)) static constexpr ::sus::result::Result<uptr,
 ::sus::num::TryFromIntError>
try_from(U* u) noexcept;

template <Unsigned U>
 requires(::sus::mem::size_of() == ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
__attribute__((pure)) static constexpr uptr from(U u) noexcept {
 if constexpr (MAX_PRIMITIVE < U::MAX_PRIMITIVE)
 ::sus::check(u.primitive_value <= MAX_PRIMITIVE);
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(u.primitive_value));
}

template <UnsignedPrimitiveInteger U>
 requires(::sus::mem::size_of() == ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
__attribute__((pure)) static constexpr uptr from(U u) noexcept {
 if constexpr (MAX_PRIMITIVE < __private::max_value())
 ::sus::check(u <= MAX_PRIMITIVE);
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(u));
}

static constexpr uptr from_product(
 ::sus::iter::Iterator<uptr> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{1u});
 for (uptr i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr uptr from_sum(::sus::iter::Iterator<uptr> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{0u});
 for (uptr i : ::sus::move(it)) p += i;
 return p;
}

template <std::same_as<uintptr_t> U>
__attribute__((pure)) constexpr inline operator U() const noexcept {

return static_cast<uintptr_t>(primitive_value);
}

__attribute__((pure)) constexpr ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type* as_mut_ptr() & noexcept {
 return &primitive_value;
}

__attribute__((pure)) constexpr const ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type* as_ptr() const& noexcept {
 return &primitive_value;
}
__attribute__((pure)) constexpr const ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    uptr l, uptr r) noexcept = default;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    uptr l, Unsigned auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
    uptr l, UnsignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(uptr l, uptr r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(uptr l, Unsigned auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::strong_ordering
operator<=>(uptr l, UnsignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline uptr operator~() const& noexcept {
  return uptr(__private::unchecked_not(primitive_value));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator+(
    uptr l, uptr r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return uptr(out.value);
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator+(
 uptr l, U r) noexcept {
 return l + ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator+(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator+(
 uptr l, U r) noexcept {
 return l + uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 (UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator+(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator+(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator+(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator-(
    uptr l, uptr r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return uptr(out.value);
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator-(
 uptr l, U r) noexcept {
 return l - ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator-(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator-(
 uptr l, U r) noexcept {
 return l - uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator-(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator-(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator-(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator*(
    uptr l, uptr r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return uptr(out.value);
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator*(
 uptr l, U r) noexcept {
 return l * ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator*(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator*(
 uptr l, U r) noexcept {
 return l * uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator*(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator*(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator*(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator/(
    uptr l, uptr r) noexcept {

::sus::check(r.primitive_value != 0u);
  return uptr(__private::unchecked_div(l.primitive_value, r.primitive_value));
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator/(
 uptr l, U r) noexcept {
 return l / ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator/(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator/(
 uptr l, U r) noexcept {
 return l / uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator/(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator/(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator/(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator%(
    uptr l, uptr r) noexcept {

::sus::check(r.primitive_value != 0u);
  return uptr(__private::unchecked_rem(l.primitive_value, r.primitive_value));
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator%(
 uptr l, U r) noexcept {
 return l % ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator%(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator%(
 uptr l, U r) noexcept {
 return l % uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator%(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator%(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator%(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator&(
    uptr l, uptr r) noexcept {
  return uptr(__private::unchecked_and(l.primitive_value, r.primitive_value));
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator&(
 uptr l, U r) noexcept {
 return l & ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator&(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator&(
 uptr l, U r) noexcept {
 return l & uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator&(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator&(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator&(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator|(
    uptr l, uptr r) noexcept {
  return uptr(__private::unchecked_or(l.primitive_value, r.primitive_value));
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator|(
 uptr l, U r) noexcept {
 return l | ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value};
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator|(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator|(
 uptr l, U r) noexcept {
 return l | uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator|(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator|(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator|(U l, uptr r) noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator^(
    uptr l, uptr r) noexcept {
  return uptr(__private::unchecked_xor(l.primitive_value, r.primitive_value));
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator^(
 uptr l, U r) noexcept {
 return l ^ ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type { r.primitive_value };
}

template <Unsigned U>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>())
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator^(
 U l, uptr r) noexcept {
 return ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{l.primitive_value} ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator^(
 uptr l, U r) noexcept {
 return l ^ uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(r));
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 ((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
[[nodiscard]] __attribute__((const)) friend constexpr inline uptr operator^(
 U l, uptr r) noexcept {
 return uptr(static_cast< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>(l)) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator^(uptr l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 ::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()))
friend constexpr inline uptr operator^(U l, uptr r) noexcept = delete;

constexpr inline void operator+=(uptr r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator+=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this += uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator-=(uptr r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this -= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator*=(uptr r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this *= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator/=(uptr r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator/=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this /= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator%=(uptr r) & noexcept {

::sus::check(r.primitive_value != 0u);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator%=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this %= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator&=(uptr r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator&=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this &= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator|=(uptr r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator|=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this |= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator^=(uptr r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator^=(::sus::num::__private::ptr_type<>::pointer_sized_type r) & noexcept {
 *this ^= uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{r.primitive_value});
}

constexpr inline void operator<<=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()));
 primitive_value <<= r.primitive_value;
}

constexpr inline void operator>>=(u32 r) & noexcept {

::sus::check(r < u32(__private::num_bits< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()));
 primitive_value >>= r.primitive_value;
}

__attribute__((pure)) constexpr uptr abs_diff(uptr other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return uptr(
        __private::unchecked_sub(primitive_value, other.primitive_value));
  } else {
    return uptr(
        __private::unchecked_sub(other.primitive_value, primitive_value));
  }
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_add(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr sus::tuple_type::Tuple<uptr, bool> overflowing_add(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr saturating_add(uptr rhs) const& noexcept {
  return uptr(__private::saturating_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) inline constexpr uptr unchecked_add(::sus::marker::UnsafeFnMarker,
                                              uptr rhs) const& noexcept {
  return uptr(__private::unchecked_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr wrapping_add(uptr rhs) const& noexcept {
  return uptr(__private::wrapping_add(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_div(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_div(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr saturating_div(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr wrapping_div(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_mul(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_mul(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr saturating_mul(uptr rhs) const& noexcept {
  return uptr(__private::saturating_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr unchecked_mul(::sus::marker::UnsafeFnMarker,
                                       uptr rhs) const& noexcept {
  return uptr(__private::unchecked_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr wrapping_mul(uptr rhs) const& noexcept {
  return uptr(__private::wrapping_mul(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_neg() const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_neg()
 const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_neg() const& noexcept {
 return (uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{0u})).wrapping_sub(*this);
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_rem(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_rem(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_rem(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr div_euclid(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_div_euclid(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_div_euclid(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_div_euclid(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_div(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr rem_euclid(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_rem_euclid(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_rem_euclid(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_rem_euclid(uptr rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0u);
  return uptr(__private::unchecked_rem(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_shl(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_shl(u32 rhs) const& noexcept {
  return uptr(
      __private::shl_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_shr(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_shr(u32 rhs) const& noexcept {
  return uptr(
      __private::shr_with_overflow(primitive_value, rhs.primitive_value).value);
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_sub(uptr rhs) const&;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_sub(
 uptr rhs) const& noexcept;

__attribute__((pure)) constexpr uptr saturating_sub(uptr rhs) const& {
  return uptr(__private::saturating_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr unchecked_sub(::sus::marker::UnsafeFnMarker,
                                       uptr rhs) const& noexcept {
  return uptr(__private::unchecked_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr uptr wrapping_sub(uptr rhs) const& noexcept {
  return uptr(__private::wrapping_sub(primitive_value, rhs.primitive_value));
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(primitive_value);
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(primitive_value);
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(primitive_value);
}

__attribute__((pure)) constexpr uptr reverse_bits() const& noexcept {
  return uptr(__private::reverse_bits(primitive_value));
}

__attribute__((pure)) constexpr uptr rotate_left(u32 n) const& noexcept {
  return uptr(__private::rotate_left(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr uptr rotate_right(u32 n) const& noexcept {
  return uptr(__private::rotate_right(primitive_value, n.primitive_value));
}

__attribute__((pure)) constexpr uptr swap_bytes() const& noexcept {
  return uptr(__private::swap_bytes(primitive_value));
}

__attribute__((pure)) constexpr uptr pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return uptr(out.value);
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_pow(
 u32 rhs) const& noexcept;

__attribute__((pure)) constexpr ::sus::tuple_type::Tuple<uptr, bool> overflowing_pow(
 u32 exp) const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_pow(u32 exp) const& noexcept {
  return uptr(__private::wrapping_pow(primitive_value, exp.primitive_value));
}

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log2() const& noexcept;

__attribute__((pure)) constexpr u32 log2() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log10() const& noexcept;

__attribute__((pure)) constexpr u32 log10() const& noexcept;

__attribute__((pure)) constexpr ::sus::option::Option<u32> checked_log(
 uptr base) const& noexcept;

__attribute__((pure)) constexpr u32 log(uptr base) const& noexcept;

__attribute__((pure)) constexpr bool is_power_of_two() const& noexcept {
 return count_ones() == uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{1u});
}

__attribute__((pure)) constexpr uptr next_power_of_two() const& noexcept {
 const auto one_less =
 __private::one_less_than_next_power_of_two(primitive_value);
 return uptr(one_less) + uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{1u});
}

__attribute__((pure)) constexpr ::sus::option::Option<uptr> checked_next_power_of_two()
 const& noexcept;

__attribute__((pure)) constexpr uptr wrapping_next_power_of_two() const& noexcept {
 const auto one_less =
 __private::one_less_than_next_power_of_two(primitive_value);
 return uptr(one_less).wrapping_add(uptr(::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type{1u}));
}

[[nodiscard]] __attribute__((pure)) static constexpr uptr from_be(const uptr& x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr uptr from_le(const uptr& x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr uptr to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr uptr to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

[[nodiscard]] __attribute__((pure)) static constexpr uptr from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr uptr from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()>&
 bytes) noexcept;

[[nodiscard]] __attribute__((pure)) static constexpr uptr from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>()>&
 bytes) noexcept;

__attribute__((pure)) constexpr usize addr() const& noexcept {
 return static_cast<decltype(std::declval<usize>().primitive_value)>(
 primitive_value);
}

};

inline constexpr uptr uptr::MIN = uptr(uptr::MIN_PRIMITIVE);

inline constexpr uptr uptr::MAX_BIT_PATTERN = uptr(uptr::MAX_PRIMITIVE);

inline constexpr u32 uptr::BITS = u32(__private::num_bits< ::sus::num::__private::ptr_type< ::sus::mem::size_of<uintptr_t>()>::unsigned_type>());

template <class T, Unsigned U>
 requires(std::constructible_from<usize, U>)
__attribute__((const)) constexpr inline T* operator+(T* t, U offset) {
 return t + size_t{offset};
}

template <class T>
constexpr inline T*& operator+=(T*& t, usize offset) {
 t += size_t{offset};
 return t;
}

template <class T>
__attribute__((const)) constexpr inline T* operator-(T* t, usize offset) {
 return t - size_t{offset};
}

template <class T>
constexpr inline T*& operator-=(T*& t, usize offset) {
 t -= size_t{offset};
 return t;
}

template <class P, Integer U>
 requires((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 std::convertible_to<U, u64>)
[[nodiscard]] __attribute__((const)) constexpr inline P operator<<(P l, U r) noexcept {

return l << u64(r).primitive_value;
}

template <class P, Integer U>
 requires((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 !std::convertible_to<U, u64>)
constexpr inline P operator<<(P l, U r) noexcept = delete;

return l >> u64(r).primitive_value;
}

template <class P, Integer U>
 requires((UnsignedPrimitiveInteger || UnsignedPrimitiveEnum) &&
 !std::convertible_to<U, u64>)
constexpr inline P operator>>(P l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u8 operator<<(
 u8 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u8::BITS);
 return u8(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u8 operator<<(u8 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u8 operator>>(
 u8 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u8::BITS);
 return u8(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u8 operator>>(u8 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u16 operator<<(
 u16 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u16::BITS);
 return u16(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u16 operator<<(u16 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u16 operator>>(
 u16 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u16::BITS);
 return u16(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u16 operator>>(u16 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u32 operator<<(
 u32 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u32::BITS);
 return u32(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u32 operator<<(u32 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u32 operator>>(
 u32 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u32::BITS);
 return u32(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u32 operator>>(u32 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u64 operator<<(
 u64 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u64::BITS);
 return u64(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u64 operator<<(u64 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline u64 operator>>(
 u64 l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < u64::BITS);
 return u64(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline u64 operator>>(u64 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline usize operator<<(
 usize l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < usize::BITS);
 return usize(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline usize operator<<(usize l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline usize operator>>(
 usize l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < usize::BITS);
 return usize(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline usize operator>>(usize l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline uptr operator<<(
 uptr l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < uptr::BITS);
 return uptr(
 __private::unchecked_shl(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline uptr operator<<(uptr l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline uptr operator>>(
 uptr l, std::convertible_to<u64> auto r) noexcept {

::sus::check(r < uptr::BITS);
 return uptr(
 __private::unchecked_shr(l.primitive_value, u64(r).primitive_value));
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline uptr operator>>(uptr l, U r) noexcept = delete;

}

::sus::num::u8 inline consteval operator""_u8(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::u8::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::u8(static_cast<decltype(::sus::num::u8::primitive_value)>(val)); };

::sus::num::u16 inline consteval operator""_u16(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::u16::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::u16(static_cast<decltype(::sus::num::u16::primitive_value)>(val)); };

::sus::num::u32 inline consteval operator""_u32(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::u32::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::u32(static_cast<decltype(::sus::num::u32::primitive_value)>(val)); };

::sus::num::u64 inline consteval operator""_u64(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::u64::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::u64(static_cast<decltype(::sus::num::u64::primitive_value)>(val)); };

::sus::num::usize inline consteval operator""_usize(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::usize::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::usize(static_cast<decltype(::sus::num::usize::primitive_value)>(val)); };

namespace sus {
using sus::num::u16;
using sus::num::u32;
using sus::num::u64;
using sus::num::u8;
using sus::num::uptr;
using sus::num::usize;
}

namespace sus::iter {

struct SizeHint {
 ::sus::num::usize lower;
 ::sus::option::Option<::sus::num::usize> upper;

friend constexpr bool operator==(const SizeHint& lhs,
                                   const SizeHint& rhs) noexcept = default;
};

}

namespace sus::option {

namespace __private {

template <class T, ::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Product<T>
constexpr Option<T> from_product_impl(Iter&& it) noexcept {
 class IterUntilNone final
 : public ::sus::iter::IteratorBase<IterUntilNone, T> {
 public:
 constexpr IterUntilNone(Iter& iter, bool& found_none)
 : iter_(iter), found_none_(found_none) {}

constexpr Option<T> next() noexcept {
 Option<Option<T>> next = iter_.next();
 Option<T> out;
 if (next.is_some()) {
 out = ::sus::move(next).unwrap_unchecked(::sus::marker::unsafe_fn);
 if (out.is_none()) found_none_ = true;
 }
 return out;
 }
 constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 return ::sus::iter::SizeHint(0u, iter_.size_hint().upper);
 }

private:
 Iter& iter_;
 bool& found_none_;
 };
 static_assert(::sus::iter::Iterator<IterUntilNone, T>);

bool found_none = false;
 auto out = Option<T>(IterUntilNone(it, found_none).product());
 if (found_none) out = Option<T>();
 return out;
}

template <class T, ::sus::iter::Iterator<Option<T>> Iter>
 requires ::sus::iter::Sum<T>
constexpr Option<T> from_sum_impl(Iter&& it) noexcept {
 class IterUntilNone final
 : public ::sus::iter::IteratorBase<IterUntilNone, T> {
 public:
 constexpr IterUntilNone(Iter& iter, bool& found_none)
 : iter_(iter), found_none_(found_none) {}

private:
 Iter& iter_;
 bool& found_none_;
 };
 static_assert(::sus::iter::Iterator<IterUntilNone, T>);

bool found_none = false;
 auto out = Option<T>(IterUntilNone(it, found_none).sum());
 if (found_none) out = Option<T>();
 return out;
}

}

namespace sus::option {

template <class ItemT>
class [[nodiscard]] OptionIter final
 : public ::sus::iter::IteratorBase<OptionIter<ItemT>, ItemT> {
 public:
 using Item = ItemT;

OptionIter(OptionIter&&) = default;
  OptionIter& operator=(OptionIter&&) = default;

constexpr OptionIter clone() const noexcept
 requires(::sus::mem::Clone<Option<Item>>)
 {
 return OptionIter(::sus::clone(item_));
 }

constexpr Option<Item> next() noexcept { return item_.take(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const usize rem = item_.is_some() ? 1u : 0u;
 return ::sus::iter::SizeHint(rem, Option<usize>(rem));
 }

constexpr Option<Item> next_back() noexcept { return item_.take(); }

constexpr usize exact_size_hint() const noexcept {
    return item_.is_some() ? 1u : 0u;
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:
 template <class U>
 friend class Option;
 template <class U, class V>
 friend class ::sus::result::Result;

constexpr OptionIter(Option<Item> item) : item_(::sus::move(item)) {}

Option<Item> item_;

};

}

namespace sus::option {

template <class T>
__attribute__((pure)) constexpr OptionIter<const std::remove_reference_t<T>&>
Option<T>::iter() const& noexcept {
 return OptionIter<const std::remove_reference_t<T>&>(as_ref());
}
template <class T>
constexpr OptionIter<const std::remove_reference_t<T>&>
Option<T>::iter() && noexcept
 requires(std::is_reference_v<T>)
{
 return OptionIter<const std::remove_reference_t<T>&>(
 ::sus::move(*this).as_ref());
}
template <class T>
constexpr OptionIter<const std::remove_reference_t<T>&> Option<T>::iter()
 const& noexcept
 requires(std::is_reference_v<T>)
{
 return ::sus::clone(*this).iter();
}

template <class T>
__attribute__((pure)) constexpr OptionIter<T&> Option<T>::iter_mut() & noexcept {
 return OptionIter<T&>(as_mut());
}
template <class T>
constexpr OptionIter<T&> Option<T>::iter_mut() && noexcept
 requires(std::is_reference_v<T>)
{
 return OptionIter<T&>(::sus::move(*this).as_mut());
}
template <class T>
constexpr OptionIter<T&> Option<T>::iter_mut() const& noexcept
 requires(std::is_reference_v<T>)
{
 return ::sus::clone(*this).iter_mut();
}

template <class T>
constexpr OptionIter<T> Option<T>::into_iter() && noexcept {
 return OptionIter<T>(take());
}
template <class T>
constexpr OptionIter<T> Option<T>::into_iter() const& noexcept
 requires(::sus::mem::CopyOrRef<T>)
{
 return ::sus::clone(*this).into_iter();
}

}

template <class T>
struct sus::iter::FromIteratorImpl<::sus::option::Option<T>> {

template <class IntoIter, int&...,
 class Iter =
 std::decay_t<decltype(std::declval<IntoIter&&>().into_iter())>,
 class O = typename Iter::Item,
 class U = ::sus::option::__private::IsOptionType<O>::inner_type>
 requires(::sus::option::__private::IsOptionType<O>::value &&
 ::sus::iter::IntoIterator<IntoIter, ::sus::option::Option>)
 static constexpr ::sus::option::Option<T> from_iter(
 IntoIter&& option_iter) noexcept
 requires(!std::is_reference_v<T> && ::sus::iter::FromIterator<T, U>)
 {

struct UntilNoneIter final
 : public ::sus::iter::IteratorBase<UntilNoneIter, U> {
 constexpr UntilNoneIter(Iter&& iter, bool& found_none)
 : iter(iter), found_none(found_none) {}

constexpr ::sus::option::Option next() noexcept {
 ::sus::option::Option<::sus::option::Option> item = iter.next();
 if (found_none || item.is_none()) return ::sus::option::Option();
 found_none = item->is_none();
 return ::sus::move(item).flatten();
 }
 constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 return ::sus::iter::SizeHint(0u, iter.size_hint().upper);
 }

Iter& iter;
      bool& found_none;
    };

bool found_none = false;
 auto iter = UntilNoneIter(::sus::move(option_iter).into_iter(), found_none);
 auto collected = Option<T>(sus::iter::from_iter<T>(::sus::move(iter)));
 if (found_none) collected = ::sus::option::Option<T>();
 return collected;
 }
};

namespace sus::iter::__private {

template <class Ordering, class ItemA, class ItemB>
constexpr inline Ordering iter_compare(
 ::sus::iter::Iterator<ItemA> auto&& a,
 ::sus::iter::Iterator<ItemB> auto&& b,
 ::sus::fn::FnMut<Ordering(const std::remove_reference_t<ItemA>&,
 const std::remove_reference_t<ItemB>&)> auto&& f)
 requires(sus::mem::IsMoveRef<decltype(f)>)
{
 Ordering value = Ordering::equivalent;
 while (true) {
 ::sus::Option<ItemA> item_a = a.next();
 ::sus::Option<ItemB> item_b = b.next();
 if (item_a.is_none() && item_b.is_none()) {
 return value;
 } else if (item_a.is_none()) {
 value = Ordering::less;
 return value;
 } else if (item_b.is_none()) {
 value = Ordering::greater;
 return value;
 } else {
 value = ::sus::fn::call_mut(f, item_a.as_value(), item_b.as_value());
 if (!(value == 0)) return value;

}
  }
}

template <class ItemA, class ItemB>
constexpr inline bool iter_compare_eq(
 ::sus::iter::Iterator<ItemA> auto&& a,
 ::sus::iter::Iterator<ItemB> auto&& b,
 ::sus::fn::FnMut<bool(const std::remove_reference_t<ItemA>&,
 const std::remove_reference_t<ItemB>&)> auto&& f)
 requires(sus::mem::IsMoveRef<decltype(f)>)
{
 bool value = true;
 while (true) {
 ::sus::Option<ItemA> item_a = a.next();
 ::sus::Option<ItemB> item_b = b.next();
 if (item_a.is_none() && item_b.is_none()) {
 return value;
 } else if (item_a.is_none()) {
 value = false;
 return value;
 } else if (item_b.is_none()) {
 value = false;
 return value;
 } else {
 value = ::sus::fn::call_mut(f, item_a.as_value(), item_b.as_value());
 if (!value) return value;

}
  }
}
}

namespace sus::iter::__private {

struct IteratorEnd {};

}

namespace sus::iter {

template <class Collection, class ItemType>
concept Extend =
 requires(Collection c, __private::IntoIteratorArchetype<ItemType>&& iter) {
 { c.extend(::sus::move(iter)) } -> std::same_as<void>;
 };

}

namespace sus::iter::__private {

template <class Iter>
class [[nodiscard]] IteratorLoop final {
 using Item = typename std::remove_reference_t<Iter>::Item;

public:
 constexpr IteratorLoop(Iter&& iter) noexcept
 : iter_(::sus::forward<Iter>(iter)), item_(iter_.next()) {}

constexpr inline bool operator==(__private::IteratorEnd) const noexcept {
    return item_.is_none();
  }
  constexpr inline void operator++() & noexcept { item_ = iter_.next(); }
  constexpr inline Item operator*() & noexcept {

return item_.take().unwrap_unchecked(::sus::marker::unsafe_fn);
  }

private:
 Iter iter_;
 Option<Item> item_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(iter_), decltype(item_)>;

};

}

namespace sus::iter {

template <class T>
 requires requires(const T& t) {
 { t.iter() };
 }
constexpr auto begin(const T& t) noexcept {
 return __private::IteratorLoop(t.iter());
}

template <class T>
 requires requires(const T& t) {
 { t.iter() };
 }
constexpr auto end(const T&) noexcept {
 return __private::IteratorEnd();
}

}

namespace sus::choice_type::__private {

template <class... Ts>
struct PackFirstHelper;

template <class T, class... Ts>
struct PackFirstHelper<T, Ts...> {
 using type = T;
};

template <class... Ts>
using PackFirst = PackFirstHelper<Ts...>::type;

template <size_t I, class... Ts>
struct PackIthHelper;

template <size_t I, class T, class... Ts>
struct PackIthHelper<I, T, Ts...> {
 using type = PackIthHelper::type;
};

template <class T, class... Ts>
struct PackIthHelper<0, T, Ts...> {
 using type = T;
};

template <size_t I, class... Ts>
using PackIth = PackIthHelper<I, Ts...>::type;

}

namespace sus::num {

template <class Rhs, class Output = Rhs>
concept Neg = requires(Rhs rhs) {
 { -static_cast<Rhs&&>(rhs) } -> std::same_as<Output>;
 };

template <class Rhs, class Output = Rhs>
concept BitNot = requires(Rhs rhs) {
 { ~static_cast<Rhs&&>(rhs) } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept Add = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs + rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept AddAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs += rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept Sub = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs - rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept SubAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs -= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept Mul = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs* rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept MulAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs *= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept Div = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs / rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept DivAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs /= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept Rem = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs % rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept RemAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs %= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept BitAnd = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs& rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept BitAndAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs &= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept BitOr = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs | rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept BitOrAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs |= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Rhs, class Output = Lhs>
concept BitXor = requires(const Lhs& lhs, const Rhs& rhs) {
 { lhs ^ rhs } -> std::same_as<Output>;
 };

template <class Lhs, class Rhs>
concept BitXorAssign = requires(Lhs& lhs, const Rhs& rhs) {
 { lhs ^= rhs } -> std::same_as<void>;
 };

template <class Lhs, class Output = Lhs>
concept Shl = requires(const Lhs& lhs ) {
 { lhs << 2u } -> std::same_as<Output>;
 };

template <class Lhs>
concept ShlAssign = requires(Lhs& lhs ) {
 { lhs <<= 2u } -> std::same_as<void>;
 };

template <class Lhs, class Output = Lhs>
concept Shr = requires(const Lhs& lhs ) {
 { lhs >> 2u } -> std::same_as<Output>;
 };

template <class Lhs>
concept ShrAssign = requires(Lhs& lhs ) {
 { lhs >>= 2u } -> std::same_as<void>;
 };

}

namespace sus::tuple_type::__private {

template <class... T>
struct TupleStorage;

template <class T>
struct TupleStorage<T> {
 TupleStorage()
 requires(std::is_trivially_default_constructible_v<T>)
 = default;

template <class U>
 constexpr inline explicit TupleStorage(U&& value)
 : value(::sus::forward(value)) {}

inline constexpr const T& at() const& noexcept { return value; }
  inline constexpr T& at_mut() & noexcept { return value; }
  inline constexpr T&& into_inner() && noexcept { return ::sus::move(value); }

private:
  [[no_unique_address]] T value;
};

template <class T>
struct TupleStorage<T&> {
 constexpr inline explicit TupleStorage(T& value)
 : value(::sus::mem::addressof(value)) {}

inline constexpr const T& at() const& noexcept { return *value; }
  inline constexpr T& at_mut() & noexcept { return *value; }
  inline constexpr T& into_inner() && noexcept { return *value; }

private:
  T* _Nonnull value;
};

template <class T, class... Ts>
 requires(sizeof...(Ts) > 0)
struct TupleStorage<T, Ts...> : TupleStorage<Ts...> {
 using Super = TupleStorage<Ts...>;

TupleStorage()
 requires(std::is_trivially_default_constructible_v<T>)
 = default;

template <class U, class... Us>
 constexpr inline TupleStorage(U&& value, Us&&... more) noexcept
 : Super(::sus::forward<Us>(more)...), value(::sus::forward(value)) {}

private:
  [[no_unique_address]] T value;
};

template <class T, class... Ts>
 requires(sizeof...(Ts) > 0)
struct TupleStorage<T&, Ts...> : TupleStorage<Ts...> {
 using Super = TupleStorage<Ts...>;

template <class... Us>
 constexpr inline TupleStorage(T& value, Us&&... more) noexcept
 : Super(::sus::forward<Us>(more)...),
 value(::sus::mem::addressof(value)) {}

inline constexpr const T& at() const& noexcept { return *value; }
  inline constexpr T& at_mut() & noexcept { return *value; }
  inline constexpr T& into_inner() && noexcept { return *value; }

private:
  T* value;
};

template <size_t I, class S>
static constexpr const auto& find_tuple_storage(const S& storage) {
 return find_tuple_storage(storage, std::integral_constant<size_t, I>());
}

template <size_t I, class S>
static constexpr const auto& find_tuple_storage(
 const S& storage, std::integral_constant<size_t, I>) {
 return find_tuple_storage(static_cast<const S::Super&>(storage),
 std::integral_constant<size_t, I - 1>());
}

template <class S>
static constexpr const S& find_tuple_storage(
 const S& storage, std::integral_constant<size_t, 0>) {
 return storage;
}

template <size_t I, class S>
static constexpr auto& find_tuple_storage_mut(S& storage) {
 return find_tuple_storage_mut(storage, std::integral_constant<size_t, I>());
}

template <size_t I, class S>
static constexpr auto& find_tuple_storage_mut(
 S& storage, std::integral_constant<size_t, I>) {
 return find_tuple_storage_mut(static_cast<S::Super&>(storage),
 std::integral_constant<size_t, I - 1>());
}

template <class S>
static constexpr S& find_tuple_storage_mut(S& storage,
 std::integral_constant<size_t, 0>) {
 return storage;
}

template <size_t I, class S1, class S2>
constexpr inline auto storage_eq_impl(const S1& l, const S2& r) noexcept {
 return find_tuple_storage(l).at() == find_tuple_storage(r).at();
};

template <class S1, class S2, size_t... N>
constexpr inline auto storage_eq(const S1& l, const S2& r,
 std::index_sequence<N...>) noexcept {
 return (... && (storage_eq_impl<N>(l, r)));
};

template <size_t I, class O, class S1, class S2>
constexpr inline bool storage_cmp_impl(O& val, const S1& l,
 const S2& r) noexcept {
 auto cmp = find_tuple_storage(l).at() <=> find_tuple_storage(r).at();

if (cmp != 0) val = cmp;

return val == 0;
};

template <class S1, class S2, size_t... N>
constexpr inline auto storage_cmp(auto equal, const S1& l, const S2& r,
 std::index_sequence<N...>) noexcept {
 auto val = equal;
 (... && (storage_cmp_impl<N>(val, l, r)));
 return val;
};

}

namespace sus {

namespace tuple_type {}
}

namespace sus::tuple_type {

template <class T, class... Ts>
class Tuple final {
 public:

explicit inline constexpr Tuple() noexcept
 requires(!((std::is_trivially_default_constructible_v<T> && ... &&
 std::is_trivially_default_constructible_v<Ts>) &&
 !(std::is_reference_v<T> || ... || std::is_reference_v<Ts>)
 ) &&
 (::sus::construct::Default<T> && ... &&
 ::sus::construct::Default<Ts>))
 : Tuple(T(), Ts()...) {}

explicit Tuple()
 requires((std::is_trivially_default_constructible_v<T> && ... &&
 std::is_trivially_default_constructible_v<Ts>) &&
 !(std::is_reference_v<T> || ... || std::is_reference_v<Ts>))
 = default;

template <std::convertible_to<T> U, std::convertible_to<Ts>... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 (sus::construct::SafelyConstructibleFromReference<T, U &&> &&
 ... &&
 sus::construct::SafelyConstructibleFromReference<Ts, Us &&>))
 explicit constexpr Tuple(U&& first, Us&&... more) noexcept
 : storage_(::sus::forward(first), ::sus::forward<Us>(more)...) {

static_assert(
 (sus::construct::SafelyConstructibleFromReference<T, U&&> && ... &&
 sus::construct::SafelyConstructibleFromReference<Ts, Us&&>),
 "Unable to safely convert to a different reference type, as "
 "conversion would produce a reference to a temporary. The Tuple's "
 "parameter type must match the Tuple's stored reference. For example a "
 "`Tuple<const i32&, u32>` can not be constructed from "
 "`const i16&, u32` parameters but it can be constructed from "
 " `i32, u16`.");
 }

constexpr Tuple clone() const& noexcept
 requires((::sus::mem::CloneOrRef<T> && ... && ::sus::mem::CloneOrRef<Ts>) &&
 !(::sus::mem::CopyOrRef<T> && ... && ::sus::mem::CopyOrRef<Ts>))
 {
 auto f = [this]<size_t... Is>(std::index_sequence<Is...>) {
 return Tuple(::sus::mem::clone_or_forward<T>(
 __private::find_tuple_storage<Is>(storage_).at())...);
 };
 return f(std::make_index_sequence<1u + sizeof...(Ts)>());
 }

template <class U, class... Us>
 requires(
 (std::convertible_to<const U&, T> && ... &&
 std::convertible_to<const Us&, Ts>) &&
 sizeof...(Ts) == sizeof...(Us) &&
 (::sus::construct::SafelyConstructibleFromReference<T, const U&> &&
 ... &&
 ::sus::construct::SafelyConstructibleFromReference<Ts, const Us&>))
 constexpr Tuple(const Tuple<U, Us...>& tuple) noexcept
 : Tuple(UNPACK, tuple, std::make_index_sequence<1u + sizeof...(Ts)>()) {

static_assert(
 (::sus::construct::SafelyConstructibleFromReference<T, const U&> &&
 ... &&
 ::sus::construct::SafelyConstructibleFromReference<Ts, const Us&>),
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The TupleMarker's value "
 "type must match the Tuple's. For example a `Tuple<const i32&, u32>` "
 "can not be constructed from a `Tuple<i16, u32>`, "
 "but it can be constructed from `Tuple<i32, u16>`.");
 }

template <class U, class... Us>
 requires((std::convertible_to && ... &&
 std::convertible_to<Us &&, Ts>) &&
 sizeof...(Ts) == sizeof...(Us) &&
 (::sus::construct::SafelyConstructibleFromReference<T, U &&> &&
 ... &&
 ::sus::construct::SafelyConstructibleFromReference<Ts, Us &&>))
 constexpr Tuple(Tuple<U, Us...>&& tuple) noexcept
 : Tuple(UNPACK, ::sus::move(tuple),
 std::make_index_sequence<1u + sizeof...(Ts)>()) {

static_assert(
 (::sus::construct::SafelyConstructibleFromReference<T, U&&> && ... &&
 ::sus::construct::SafelyConstructibleFromReference<Ts, Us&&>),
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The TupleMarker's value "
 "type must match the Tuple's. For example a `Tuple<const i32&, u32>` "
 "can not be constructed from a `Tuple<i16, u32>`, "
 "but it can be constructed from `Tuple<i32, u16>`.");
 }

template <size_t I>
 requires(I <= sizeof...(Ts))
 constexpr inline const auto& at() const& noexcept {
 return __private::find_tuple_storage(storage_).at();
 }

template <size_t I>
 constexpr inline const auto& at() && = delete;

template <size_t I>
 requires(I <= sizeof...(Ts))
 constexpr inline auto& at_mut() & noexcept {
 return __private::find_tuple_storage_mut(storage_).at_mut();
 }

template <size_t I>
 requires(I <= sizeof...(Ts))
 constexpr inline decltype(auto) into_inner() && noexcept {
 return ::sus::move(__private::find_tuple_storage_mut(storage_))
 .into_inner();
 }

constexpr bool operator==(const Tuple& r) const& noexcept
 requires((::sus::cmp::Eq<T> && ... && ::sus::cmp::Eq<Ts>))
 {
 return __private::storage_eq(
 storage_, r.storage_, std::make_index_sequence<1u + sizeof...(Ts)>());
 }
 template <class U, class... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 (::sus::cmp::Eq<T, U> && ... && ::sus::cmp::Eq<Ts, Us>))
 constexpr bool operator==(const Tuple<U, Us...>& r) const& noexcept {
 return __private::storage_eq(
 storage_, r.storage_, std::make_index_sequence<1u + sizeof...(Ts)>());
 }

constexpr std::strong_ordering operator<=>(const Tuple& r) const& noexcept
 requires((::sus::cmp::StrongOrd<T> && ... && ::sus::cmp::StrongOrd<Ts>))
 {
 return __private::storage_cmp(
 std::strong_ordering::equal, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }
 template <class U, class... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 (::sus::cmp::StrongOrd<T, U> && ... &&
 ::sus::cmp::StrongOrd<Ts, Us>))
 constexpr std::strong_ordering operator<=>(
 const Tuple<U, Us...>& r) const& noexcept {
 return __private::storage_cmp(
 std::strong_ordering::equal, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }

constexpr std::weak_ordering operator<=>(const Tuple& r) const& noexcept
 requires(!(::sus::cmp::StrongOrd<T> && ... && ::sus::cmp::StrongOrd<Ts>) &&
 (::sus::cmp::Ord<T> && ... && ::sus::cmp::Ord<Ts>))
 {
 return __private::storage_cmp(
 std::weak_ordering::equivalent, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }
 template <class U, class... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 !(::sus::cmp::StrongOrd<T, U> && ... &&
 ::sus::cmp::StrongOrd<Ts, Us>) &&
 (::sus::cmp::Ord<T, U> && ... && ::sus::cmp::Ord<Ts, Us>))
 constexpr std::weak_ordering operator<=>(
 const Tuple<U, Us...>& r) const& noexcept {
 return __private::storage_cmp(
 std::weak_ordering::equivalent, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }

constexpr std::partial_ordering operator<=>(const Tuple& r) const& noexcept
 requires(!(::sus::cmp::Ord<T> && ... && ::sus::cmp::Ord<Ts>) &&
 (::sus::cmp::PartialOrd<T> && ... && ::sus::cmp::PartialOrd<Ts>))
 {
 return __private::storage_cmp(
 std::partial_ordering::equivalent, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }
 template <class U, class... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 !(::sus::cmp::Ord<T, U> && ... && ::sus::cmp::Ord<Ts, Us>) &&
 (::sus::cmp::PartialOrd<T, U> && ... &&
 ::sus::cmp::PartialOrd<Ts, Us>))
 constexpr std::partial_ordering operator<=>(
 const Tuple<U, Us...>& r) const& noexcept {
 return __private::storage_cmp(
 std::partial_ordering::equivalent, storage_, r.storage_,
 std::make_index_sequence<1u + sizeof...(Ts)>());
 }

template <class U, class... Us>
 requires(sizeof...(Us) == sizeof...(Ts) &&
 (::sus::iter::Extend<T, U> && ... && ::sus::iter::Extend<Ts, Us>))
 constexpr void extend(
 ::sus::iter::IntoIterator<Tuple<U, Us...>> auto&& ii) noexcept
 requires(::sus::mem::IsMoveRef<decltype(ii)>)
 {
 for (Tuple<U, Us...>&& item : ::sus::move(ii).into_iter()) {
 auto f = [this]<size_t... Is>(Tuple<U, Us...>&& item,
 std::index_sequence<Is...>) mutable {

using Items = Tuple<U, Us...>;

(..., at_mut<Is>().extend(
 ::sus::option::Option<typename Items::template IthType<Is>>(
 ::sus::move(item).template into_inner<Is>())));
 };
 f(::sus::move(item), std::make_index_sequence<1u + sizeof...(Ts)>());
 }
 }

private:
 template <class U, class... Us>
 friend class Tuple;

enum UnpackContructor { UNPACK };
 template <class U, class... Us, size_t... Is>
 explicit constexpr Tuple(UnpackContructor, const Tuple<U, Us...>& tuple,
 std::index_sequence<Is...>) noexcept
 : Tuple(__private::find_tuple_storage<Is>(tuple.storage_).at()...) {}
 template <class U, class... Us, size_t... Is>
 explicit constexpr Tuple(UnpackContructor, Tuple<U, Us...>&& tuple,
 std::index_sequence<Is...>) noexcept
 : Tuple(::sus::move(__private::find_tuple_storage_mut<Is>(tuple.storage_))
 .into_inner()...) {}

using Storage = __private::TupleStorage<T, Ts...>;

template <size_t I>
 using IthType = ::sus::choice_type::__private::PackIth<I, T, Ts...>;

[[no_unique_address]] Storage storage_;

template <class... Ts>
Tuple(Ts&&...) -> Tuple<std::remove_cvref_t<Ts>...>;

template <size_t I, class... Ts>
constexpr decltype(auto) get(const Tuple<Ts...>& t) noexcept {
 return t.template at();
}
template <size_t I, class... Ts>
constexpr decltype(auto) get(Tuple<Ts...>& t) noexcept {
 return t.template at_mut();
}
template <size_t I, class... Ts>
constexpr decltype(auto) get(Tuple<Ts...>&& t) noexcept {

return static_cast<decltype(::sus::move(t).template into_inner())>(
 t.template at_mut());
}

namespace __private {
template <class... Ts>
struct [[nodiscard]] TupleMarker {
 explicit constexpr TupleMarker(Tuple<Ts&&...>&& values)
 : values(::sus::move(values)) {}

Tuple<Ts&&...> values;

template <class... Us>
 __attribute__((pure)) inline constexpr operator Tuple<Us...>() const& noexcept {
 static_assert(
 (... &&
 std::convertible_to<::sus::mem::remove_rvalue_reference<Ts>, Us>),
 "TupleMarker(T) can't convert const T& to U for Tuple. "
 "Note that this is a test-only code path for Gtest support. "
 "Typically the T object is consumed as an rvalue, consider using "
 "EXPECT_TRUE(a == b) if needed.");
 static_assert((... && std::convertible_to<Ts&&, Us>),
 "TupleMarker(T) can't convert T to U for Tuple");
 static_assert(
 (... &&
 ::sus::construct::SafelyConstructibleFromReference<Us, const Ts&>),
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The TupleMarker's value "
 "type must match the Tuple's. For example a `Tuple<const i32&, u32>` "
 "can not be constructed from a TupleMarker holding `const i16&, u32`, "
 "but it can be constructed from `i32&&, u16`.");
 auto make_tuple =
 [this]<size_t... Is>(std::integer_sequence<size_t, Is...>) {
 return Tuple<Us...>(Us(values.template at<Is>())...);
 };
 return make_tuple(std::make_integer_sequence<size_t, sizeof...(Ts)>());
 }

template <class... Us>
 inline constexpr operator Tuple<Us...>() && noexcept {
 static_assert((... && std::convertible_to<Ts&&, Us>),
 "TupleMarker(T) can't convert T to U for Tuple");
 static_assert(
 (... && ::sus::construct::SafelyConstructibleFromReference<Us, Ts&&>),
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The TupleMarker's value "
 "type must match the Tuple's. For example a `Tuple<const i32&, u32>` "
 "can not be constructed from a TupleMarker holding `const i16&, u32`, "
 "but it can be constructed from `i32&&, u16`.");
 auto make_tuple = [this]<size_t... Is>(
 std::integer_sequence<size_t, Is...>) {
 return Tuple<Us...>(::sus::forward<Ts>(values.template at_mut<Is>())...);
 };
 return make_tuple(std::make_integer_sequence<size_t, sizeof...(Ts)>());
 }

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

}

template <class... Ts>
 requires(sizeof...(Ts) > 0)
[[nodiscard]] inline constexpr auto tuple(
 Ts&&... vs [[clang::lifetimebound]]) noexcept {
 return __private::TupleMarker<Ts...>(
 ::sus::tuple_type::Tuple<Ts&&...>(::sus::forward<Ts>(vs)...));
}

}

namespace std {
template <class... Types>
struct tuple_size<::sus::tuple_type::Tuple<Types...>> {
 static constexpr size_t value = sizeof...(Types);
};

template <size_t I, class T, class... Types>
struct tuple_element<I, ::sus::tuple_type::Tuple<T, Types...>> {
 using type = tuple_element>::type;
};

template <class T, class... Types>
struct tuple_element<0, ::sus::tuple_type::Tuple<T, Types...>> {
 using type = T;
};

}

template <class... Types, class Char>
struct fmt::formatter<::sus::tuple_type::Tuple<Types...>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return ctx.begin();
 }

template <class FormatContext>
 constexpr auto format(const ::sus::tuple_type::Tuple<Types...>& tuple,
 FormatContext& ctx) const {
 auto out = ctx.out();
 *out++ = static_cast<Char>('(');
 ctx.advance_to(out);
 out =
 format_tuple(tuple, ctx, std::make_index_sequence<sizeof...(Types)>());
 *out++ = static_cast<Char>(')');
 return out;
 }

private:
 template <size_t... Is, class FormatContext>
 static auto format_tuple(const ::sus::tuple_type::Tuple<Types...>& tuple,
 FormatContext& ctx, std::index_sequence<Is...>) {
 (..., format_value<Is>(tuple, ctx));
 return ctx.out();
 }

template <size_t I, class FormatContext>
 static void format_value(const ::sus::tuple_type::Tuple<Types...>& tuple,
 FormatContext& ctx) {
 using ValueFormatter =
 ::sus::string::__private::AnyFormatter<decltype(tuple.template at()),
 Char>;
 auto out = ValueFormatter().format(tuple.template at(), ctx);
 if constexpr (I < sizeof...(Types) - 1) {
 *out++ = static_cast<Char>(',');
 *out++ = static_cast<Char>(' ');
 ctx.advance_to(out);
 }
 }
};

namespace sus::tuple_type {
template <class... Types,
 ::sus::string::__private::StreamCanReceiveString<char> StreamType>
inline StreamType& operator<<(StreamType& stream,
 const Tuple<Types...>& value) {
 return ::sus::string::__private::format_to_stream(stream,
 fmt::to_string(value));
}
}

namespace sus {
using ::sus::tuple_type::Tuple;
using ::sus::tuple_type::tuple;
}

namespace sus::iter {

using ::sus::construct::Into;
using ::sus::option::Option;

template <class Iter, class ItemT>
class IteratorBase {
 protected:
 constexpr IteratorBase() noexcept {

static_assert(std::same_as<ItemT, typename Iter::Item>);
 static_assert(std::is_final_v<Iter>,
 "Iterator implementations must be `final`, as the provided "
 "methods must know the complete type.");
 }

constexpr inline const Iter& as_subclass() const {
 return static_cast<const Iter&>(*this);
 }
 constexpr inline Iter& as_subclass_mut() { return static_cast<Iter&>(*this); }

public:
  using Item = ItemT;

constexpr auto begin() & noexcept {
 return __private::IteratorLoop<Iter&>(as_subclass_mut());
 }

constexpr auto end() & noexcept { return __private::IteratorEnd(); }

constexpr Iter&& into_iter() && noexcept {
 return static_cast<Iter&&>(*this);
 }

constexpr bool all(::sus::fn::FnMut<bool(Item)> auto f) noexcept;

constexpr bool any(::sus::fn::FnMut<bool(Item)> auto f) noexcept;

constexpr Iterator<Item> auto by_ref() & noexcept;

template <IntoIterator<ItemT> Other>
 constexpr Iterator<Item> auto chain(Other&& other) && noexcept;

constexpr Iterator<std::remove_cvref_t<Item>> auto cloned() && noexcept
 requires(::sus::mem::Clone<Item>);

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 requires(::sus::cmp::Ord<ItemT, OtherItem>)
 constexpr std::weak_ordering cmp(Other&& other) && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 constexpr std::weak_ordering cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept;

constexpr Iterator<std::remove_cvref_t<Item>> auto copied() && noexcept
 requires(::sus::mem::Copy<Item>);

constexpr ::sus::num::usize count() && noexcept;

constexpr Iterator<Item> auto cycle() && noexcept
 requires(::sus::mem::Clone<Iter>);

constexpr auto enumerate() && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 requires(::sus::cmp::Eq<ItemT, OtherItem>)
 constexpr bool eq(Other&& other) && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 constexpr bool eq_by(
 Other&& other,
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto
 eq_fn) && noexcept;

constexpr Iterator<Item> auto filter(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept;

template <
 ::sus::fn::FnMut<::sus::fn::NonVoid(ItemT&&)> MapFn, int&...,
 class R = std::invoke_result_t<MapFn&, ItemT&&>,
 class InnerR = ::sus::option::__private::IsOptionType<R>::inner_type>
 requires(::sus::option::__private::IsOptionType<R>::value)
 constexpr Iterator<InnerR> auto filter_map(MapFn f) && noexcept;

constexpr Option<Item> find(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) noexcept;

template <
 ::sus::fn::FnMut<::sus::fn::NonVoid(ItemT&&)> FindFn, int&...,
 class R = std::invoke_result_t<FindFn&, ItemT&&>,
 class InnerR = ::sus::option::__private::IsOptionType<R>::inner_type>
 requires(::sus::option::__private::IsOptionType<R>::value)
 constexpr Option<InnerR> find_map(FindFn f) noexcept;

template <::sus::fn::FnMut<::sus::fn::NonVoid(ItemT&&)> F, int&...,
 class R = std::invoke_result_t<F&, ItemT&&>,
 class InnerR = IntoIteratorOutputType<R>::Item>
 requires(IntoIteratorAny<R>)
 constexpr Iterator<InnerR> auto flat_map(F f) && noexcept;

constexpr auto flatten() && noexcept
 requires(IntoIteratorAny<Item>);

template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, ItemT)> F>
 requires(std::convertible_to<std::invoke_result_t<F&, B &&, ItemT &&>, B> &&
 (!std::is_reference_v ||
 std::is_reference_v<std::invoke_result_t<F&, B &&, ItemT &&>>))
 constexpr B fold(B init, F f) && noexcept;

template <::sus::fn::FnMut<void(ItemT&&)> F>
 constexpr void for_each(F f) && noexcept;

constexpr Iterator<Item> auto fuse() && noexcept;

template <::sus::fn::FnOnce<::sus::fn::NonVoid(Iter&&)> GenFn, int&...,
 class R = std::invoke_result_t<GenFn&&, Iter&&>,
 class GenR = __private::IsGenerator<R>::type>
 requires(__private::IsGenerator<R>::value)
 Iterator<GenR> auto generate(GenFn generator_fn) && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 requires(::sus::cmp::PartialOrd<ItemT, OtherItem>)
 constexpr bool ge(Other&& other) && noexcept;

constexpr Iterator<Item> auto inspect(
 ::sus::fn::FnMut<void(const std::remove_reference_t<Item>&)> auto
 fn) && noexcept;

constexpr bool is_sorted() noexcept
 requires(::sus::cmp::Ord<Item>);

constexpr bool is_sorted_by(
 ::sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) noexcept;

constexpr Option<Item> last() && noexcept;

template <::sus::fn::FnMut<::sus::fn::NonVoid(ItemT&&)> MapFn, int&...,
 class R = std::invoke_result_t<MapFn&, ItemT&&>>
 constexpr Iterator<R> auto map(MapFn fn) && noexcept;

constexpr Option<Item> max() && noexcept
 requires(::sus::cmp::Ord<Item>);

constexpr Option<Item> max_by(
 sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) && noexcept;

template <::sus::fn::FnMut<
 ::sus::fn::NonVoid(const std::remove_reference_t<ItemT>&)>
 KeyFn,
 int&...,
 class Key = std::invoke_result_t<
 KeyFn&, const std::remove_reference_t<ItemT>&>>
 requires(::sus::cmp::Ord<Key> &&
 !std::is_reference_v<Key>)
 constexpr Option<Item> max_by_key(KeyFn fn) && noexcept;

constexpr Option<Item> min() && noexcept
 requires(::sus::cmp::Ord<Item>);

constexpr Option<Item> min_by(
 sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) && noexcept;

constexpr Option<Item> nth(usize n) noexcept;

constexpr Option<Item> nth_back(usize n) noexcept
 requires(DoubleEndedIterator<Iter, Item>);

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 constexpr std::partial_ordering partial_cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::partial_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept;

template <class B>
 requires(::sus::construct::Default &&
 Extend<B, ItemT>)
 constexpr sus::Tuple<B, B> partition(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept;

constexpr Iterator<Item> auto peekable() && noexcept;

constexpr Option<usize> position(
 ::sus::fn::FnMut<bool(Item&&)> auto pred) noexcept;

template <class P = ItemT>
 requires(Product<P, ItemT>)
 constexpr P product() && noexcept;

constexpr IteratorRange<Iter> range() && noexcept;

template <::sus::fn::FnMut<ItemT(ItemT, ItemT)> F, int&...,
 class R = std::invoke_result_t<F&, ItemT&&, ItemT&&>>
 requires(!std::is_reference_v<ItemT> ||
 std::is_reference_v<R>)
 constexpr Option<Item> reduce(F f) && noexcept;

constexpr Iterator<Item> auto rev() && noexcept
 requires(DoubleEndedIterator<Iter, Item>);

constexpr Option<Item> rfind(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) noexcept
 requires(DoubleEndedIterator<Iter, Item>);

template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, ItemT)> F>
 requires(DoubleEndedIterator<Iter, ItemT> &&
 std::convertible_to<std::invoke_result_t<F&, B &&, ItemT &&>, B> &&
 (!std::is_reference_v ||
 std::is_reference_v<std::invoke_result_t<F&, B &&, ItemT &&>>))
 constexpr B rfold(B init, F f) && noexcept;

constexpr Option<usize> rposition(
 ::sus::fn::FnMut<bool(Item&&)> auto pred) noexcept
 requires(DoubleEndedIterator<Iter, Item> &&
 ExactSizeIterator<Iter, Item>);

template <
 class State, ::sus::fn::FnMut<::sus::fn::NonVoid(State&, ItemT&&)> F,
 int&..., class R = std::invoke_result_t<F&, State&, ItemT&&>,
 class InnerR = ::sus::option::__private::IsOptionType<R>::inner_type>
 requires(::sus::option::__private::IsOptionType<R>::value &&
 !std::is_reference_v<State>)
 constexpr Iterator<InnerR> auto scan(State initial_state, F f) && noexcept;

constexpr Iterator<Item> auto skip(usize n) && noexcept;

constexpr Iterator<Item> auto skip_while(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept;

constexpr Iterator<Item> auto step_by(usize step) && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 requires(::sus::cmp::StrongOrd<ItemT, OtherItem>)
 constexpr std::strong_ordering strong_cmp(Other&& other) && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 constexpr std::strong_ordering strong_cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::strong_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept;

template <class P = ItemT>
 requires(Sum<P, ItemT>)
 constexpr P sum() && noexcept;

constexpr Iterator<Item> auto take(usize n) && noexcept;

constexpr Iterator<Item> auto take_while(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept;

template <class C>
 requires(::sus::ops::Try<ItemT> &&
 FromIterator<C, ::sus::ops::TryOutputType<ItemT>> &&

!std::is_void_v<::sus::ops::TryOutputType<ItemT>>)
 constexpr auto try_collect() noexcept;

template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, ItemT)> F, int&...,
 class R = std::invoke_result_t<F&, B&&, ItemT&&>>
 requires(::sus::ops::Try<R> &&
 std::convertible_to<typename ::sus::ops::TryImpl<R>::Output, B>)
 constexpr R try_fold(B init, F f) noexcept;

template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, ItemT)> F, int&...,
 class R = std::invoke_result_t<F&, B&&, ItemT&&>>
 requires(DoubleEndedIterator<Iter, ItemT> &&
 ::sus::ops::Try<R> &&
 std::convertible_to<typename ::sus::ops::TryImpl<R>::Output, B>)
 constexpr R try_rfold(B init, F f) noexcept;

template <::sus::fn::FnMut<::sus::fn::NonVoid(ItemT)> F, int&...,
 class R = std::invoke_result_t<F&, ItemT&&>>
 requires(::sus::ops::TryDefault<R>)
 constexpr R try_for_each(F f) noexcept;

template <class CollectionA, class CollectionB, int&...,
 class ItemA =
 ::sus::option::__private::IsTupleOfSizeTwo<ItemT>::first_type,
 class ItemB =
 ::sus::option::__private::IsTupleOfSizeTwo<ItemT>::second_type>
 requires(::sus::option::__private::IsTupleOfSizeTwo<ItemT>::value &&
 ::sus::construct::Default<CollectionA> &&
 ::sus::construct::Default<CollectionB> &&
 Extend<CollectionA, ItemA> &&
 Extend<CollectionB, ItemB>)
 constexpr sus::Tuple<CollectionA, CollectionB> unzip() && noexcept;

template <IntoIteratorAny Other, int&...,
 class OtherItem = typename IntoIteratorOutputType<Other>::Item>
 constexpr Iterator<sus::Tuple<ItemT, OtherItem>> auto zip(
 Other&& other) && noexcept;

template <FromIterator<ItemT> C>
 constexpr C collect() && noexcept;

constexpr ::sus::collections::Vec<ItemT> collect_vec() && noexcept;
};

template <class Iter, class Item>
constexpr bool IteratorBase<Iter, Item>::all(
 ::sus::fn::FnMut<bool(Item)> auto f) noexcept {
 while (true) {
 Option<Item> item = as_subclass_mut().next();
 if (item.is_none()) return true;

if (!::sus::fn::call_mut(
            f, ::sus::move(item).unwrap_unchecked(::sus::marker::unsafe_fn)))
      return false;
  }
}

template <class Iter, class Item>
constexpr bool IteratorBase<Iter, Item>::any(
 ::sus::fn::FnMut<bool(Item)> auto f) noexcept {
 while (true) {
 Option<Item> item = as_subclass_mut().next();
 if (item.is_none()) return false;

if (::sus::fn::call_mut(
            f, ::sus::move(item).unwrap_unchecked(::sus::marker::unsafe_fn)))
      return true;
  }
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::by_ref() & noexcept {
 return ByRef<Iter>(as_subclass_mut());
}

template <class Iter, class Item>
template <IntoIterator<Item> Other>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::chain(
 Other&& other) && noexcept {
 using Chain = Chain<Iter, IntoIteratorOutputType<Other>>;
 return Chain(static_cast<Iter&&>(*this), ::sus::move(other).into_iter());
}

template <class Iter, class Item>
constexpr Iterator<std::remove_cvref_t<Item>> auto
IteratorBase<Iter, Item>::cloned() && noexcept
 requires(::sus::mem::Clone<Item>)
{
 using Cloned = Cloned<Iter>;
 return Cloned(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::Ord<Item, OtherItem>)
constexpr std::weak_ordering IteratorBase<Iter, Item>::cmp(
 Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).cmp_by(
 ::sus::move(other),
 [](const std::remove_reference_t<Item>& x,
 const std::remove_reference_t<OtherItem>& y) { return x <=> y; });
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
constexpr std::weak_ordering IteratorBase<Iter, Item>::cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept {
 return __private::iter_compare<std::weak_ordering, Item, OtherItem>(
 static_cast<Iter&&>(*this), ::sus::move(other).into_iter(),
 ::sus::move(cmp));
}

template <class Iter, class Item>
Iterator<std::remove_cvref_t<Item>> auto constexpr IteratorBase<
 Iter, Item>::copied() && noexcept
 requires(::sus::mem::Copy<Item>)
{
 using Copied = Copied<Iter>;
 return Copied(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr ::sus::num::usize IteratorBase<Iter, Item>::count() && noexcept {
 auto c = 0_usize;
 while (as_subclass_mut().next().is_some()) c += 1_usize;
 return c;
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::cycle() && noexcept
 requires(::sus::mem::Clone<Iter>)
{
 using Cycle = Cycle<Iter>;
 return Cycle(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr auto IteratorBase<Iter, Item>::enumerate() && noexcept {
 using Enumerate = Enumerate<Iter>;
 return Enumerate(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::Eq<Item, OtherItem>)
constexpr bool IteratorBase<Iter, Item>::eq(Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).eq_by(
 ::sus::move(other),
 [](const std::remove_reference_t<Item>& x,
 const std::remove_reference_t<OtherItem>& y) { return x == y; });
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
constexpr bool IteratorBase<Iter, Item>::eq_by(
 Other&& other,
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto
 eq_fn) && noexcept {
 return __private::iter_compare_eq<Item, OtherItem>(
 static_cast<Iter&&>(*this), ::sus::move(other).into_iter(),
 ::sus::move(eq_fn));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::filter(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept {
 using Filter = Filter<Iter, decltype(pred)>;
 return Filter(::sus::move(pred), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item&&)> MapFn, int&..., class R,
 class InnerR>
 requires(::sus::option::__private::IsOptionType<R>::value)
constexpr Iterator<InnerR> auto IteratorBase<Iter, Item>::filter_map(
 MapFn f) && noexcept {
 using FilterMap = FilterMap<InnerR, Iter, decltype(f)>;
 return FilterMap(::sus::move(f), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::find(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) noexcept {
 while (true) {
 Option<Item> o = as_subclass_mut().next();
 if (o.is_none() || ::sus::fn::call_mut(pred, o.as_value())) return o;
 }
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item&&)> FindFn, int&..., class R,
 class InnerR>
 requires(::sus::option::__private::IsOptionType<R>::value)
constexpr Option<InnerR> IteratorBase<Iter, Item>::find_map(FindFn f) noexcept {
 while (true) {
 Option<Option<InnerR>> o = as_subclass_mut().next().map(f);
 if (o.is_none()) return sus::Option<InnerR>();
 if (o.as_value().is_some()) return sus::move(o).flatten();
 }
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item&&)> F, int&..., class R,
 class InnerR>
 requires(IntoIteratorAny<R>)
constexpr Iterator<InnerR> auto IteratorBase<Iter, Item>::flat_map(
 F fn) && noexcept {
 using FlatMap = FlatMap<R, Iter, F>;
 return FlatMap(::sus::move(fn), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr auto IteratorBase<Iter, Item>::flatten() && noexcept
 requires(IntoIteratorAny<Item>)
{
 using Flatten = Flatten<IntoIteratorOutputType<Item>, Iter>;
 return Flatten(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, Item)> F>
 requires(std::convertible_to<std::invoke_result_t<F&, B &&, Item &&>, B> &&
 (!std::is_reference_v ||
 std::is_reference_v<std::invoke_result_t<F&, B &&, Item &&>>))
constexpr B IteratorBase<Iter, Item>::fold(B init, F f) && noexcept {
 if constexpr (std::is_reference_v) {
 std::remove_reference_t* out = ::sus::mem::addressof(init);
 while (true) {
 if (Option<Item> o = as_subclass_mut().next(); o.is_none())
 return *out;
 else
 out = ::sus::mem::addressof(
 ::sus::fn::call_mut(f, *out, sus::move(o).unwrap()));
 }
 } else {
 while (true) {
 if (Option<Item> o = as_subclass_mut().next(); o.is_none())
 return init;
 else
 init = ::sus::fn::call_mut(f, ::sus::move(init), sus::move(o).unwrap());
 }
 }
}

template <class Iter, class Item>
template <::sus::fn::FnMut<void(Item&&)> F>
constexpr void IteratorBase<Iter, Item>::for_each(F f) && noexcept {

while (true) {
 if (Option<Item> o = as_subclass_mut().next(); o.is_none())
 break;
 else
 ::sus::fn::call_mut(f, std::move(o).unwrap());
 }
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::fuse() && noexcept {
 return Fuse<Iter>(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <::sus::fn::FnOnce<::sus::fn::NonVoid(Iter&&)> GenFn, int&..., class R,
 class GenR>
 requires(__private::IsGenerator<R>::value)
Iterator<GenR> auto IteratorBase<Iter, Item>::generate(
 GenFn generator_fn) && noexcept {
 return ::sus::fn::call_once(::sus::move(generator_fn),
 static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::PartialOrd<Item, OtherItem>)
constexpr bool IteratorBase<Iter, Item>::ge(Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).partial_cmp(::sus::move(other)) >= 0;
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::PartialOrd<Item, OtherItem>)
constexpr bool IteratorBase<Iter, Item>::gt(Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).partial_cmp(::sus::move(other)) > 0;
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::inspect(
 ::sus::fn::FnMut<void(const std::remove_reference_t<Item>&)> auto
 fn) && noexcept {
 using Inspect = Inspect<Iter, decltype(fn)>;
 return Inspect(::sus::move(fn), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr bool IteratorBase<Iter, Item>::is_sorted() noexcept
 requires(::sus::cmp::Ord<Item>)
{
 return is_sorted_by(
 [](const std::remove_reference_t<Item>& a,
 const std::remove_reference_t<Item>& b) { return a <=> b; });
}

template <class Iter, class Item>
constexpr bool IteratorBase<Iter, Item>::is_sorted_by(
 ::sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) noexcept {
 Option<Item> o = as_subclass_mut().next();
 if (o.is_none()) return true;

if constexpr (std::is_reference_v<Item>) {
 std::remove_reference_t<Item>* last =
 ::sus::mem::addressof(sus::move(o).unwrap());
 return static_cast<Iter&&>(*this).all([&last, &compare](Item item) -> bool {
 auto ord = ::sus::fn::call_mut(compare, *last, item);
 if (ord > 0) return false;
 last = ::sus::mem::addressof(item);
 return true;
 });
 } else {
 Item last = sus::move(o).unwrap();
 return static_cast<Iter&&>(*this).all([&last, &compare](Item item) -> bool {
 auto ord = ::sus::fn::call_mut(compare, last, item);
 if (ord > 0) return false;
 last = sus::move(item);
 return true;
 });
 }
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::PartialOrd<Item, OtherItem>)
constexpr bool IteratorBase<Iter, Item>::le(Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).partial_cmp(::sus::move(other)) <= 0;
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::PartialOrd<Item, OtherItem>)
constexpr bool IteratorBase<Iter, Item>::lt(Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).partial_cmp(::sus::move(other)) < 0;
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::last() && noexcept {
 return static_cast<Iter&&>(*this).fold(
 Option<Item>(),
 [](Option<Item>&&, Item&& cur) { return Option<Item>(cur); });
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item&&)> MapFn, int&..., class R>
constexpr Iterator<R> auto IteratorBase<Iter, Item>::map(MapFn fn) && noexcept {
 using Map = Map<R, Iter, MapFn>;
 return Map(sus::move(fn), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item&&)> MapFn, int&..., class R,
 class InnerR>
 requires(::sus::option::__private::IsOptionType<R>::value)
constexpr Iterator<InnerR> auto IteratorBase<Iter, Item>::map_while(
 MapFn fn) && noexcept {
 using MapWhile = MapWhile<InnerR, Iter, MapFn>;
 return MapWhile(sus::move(fn), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::max() && noexcept
 requires(::sus::cmp::Ord<Item>)
{
 return static_cast<Iter&&>(*this).max_by(
 [](const std::remove_reference_t<Item>& a,
 const std::remove_reference_t<Item>& b) { return a <=> b; });
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::max_by(
 sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) && noexcept {
 return static_cast<Iter&&>(*this).reduce(
 [&compare](Item acc, Item item) -> Item {
 auto acc_cref = static_cast<const std::remove_reference_t<Item>&>(acc);
 if (::sus::fn::call_mut(compare, item, acc_cref) >= 0)
 return ::sus::forward<Item>(item);
 return ::sus::forward<Item>(acc);
 });
}

template <class Iter, class Item>
template <
 ::sus::fn::FnMut<::sus::fn::NonVoid(const std::remove_reference_t<Item>&)>
 KeyFn,
 int&...,
 class Key>
 requires(::sus::cmp::Ord<Key> &&
 !std::is_reference_v<Key>)
constexpr Option<Item> IteratorBase<Iter, Item>::max_by_key(
 KeyFn fn) && noexcept {

auto key = [](KeyFn keyfn) {
 return [keyfn](Item&& item) {
 return sus::Tuple<Key, Item>(keyfn(item), sus::forward<Item>(item));
 };
 };

auto compare = [](const sus::Tuple<Key, Item>& x,
 const sus::Tuple<Key, Item>& y) {
 return x.template at<0>() <=> y.template at<0>();
 };

return static_cast<Iter&&>(*this).map(key(fn)).max_by(compare).map(
 [](auto&& key_item) -> Item {
 return sus::move(key_item).template into_inner<1>();
 });
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::min() && noexcept
 requires(::sus::cmp::Ord<Item>)
{
 return static_cast<Iter&&>(*this).min_by(
 [](const std::remove_reference_t<Item>& a,
 const std::remove_reference_t<Item>& b) { return a <=> b; });
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::min_by(
 sus::fn::FnMut<std::weak_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<Item>&)> auto compare) && noexcept {
 return static_cast<Iter&&>(*this).reduce(
 [&compare](Item acc, Item item) -> Item {
 auto acc_cref = static_cast<const std::remove_reference_t<Item>&>(acc);
 if (::sus::fn::call_mut(compare, item, acc_cref) < 0)
 return ::sus::forward<Item>(item);
 return ::sus::forward<Item>(acc);
 });
}

auto key = [](KeyFn keyfn) {
 return [keyfn](Item&& item) {
 return sus::Tuple<Key, Item>(keyfn(item), sus::forward<Item>(item));
 };
 };

auto compare = [](const sus::Tuple<Key, Item>& x,
 const sus::Tuple<Key, Item>& y) {
 return x.template at<0>() <=> y.template at<0>();
 };

return static_cast<Iter&&>(*this).map(key(fn)).min_by(compare).map(
 [](auto&& key_item) -> Item {
 return sus::move(key_item).template into_inner<1>();
 });
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::nth(usize n) noexcept {
 while (true) {
 if (n == 0u) return as_subclass_mut().next();
 if (as_subclass_mut().next().is_none()) return Option<Item>();
 n -= 1u;
 }
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::nth_back(usize n) noexcept
 requires(DoubleEndedIterator<Iter, Item>)
{
 while (true) {
 if (n == 0u) return as_subclass_mut().next_back();
 if (as_subclass_mut().next_back().is_none()) return Option<Item>();
 n -= 1u;
 }
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::PartialOrd<Item, OtherItem>)
constexpr std::partial_ordering IteratorBase<Iter, Item>::partial_cmp(
 Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).partial_cmp_by(
 ::sus::move(other),
 [](const std::remove_reference_t<Item>& x,
 const std::remove_reference_t<OtherItem>& y) -> std::partial_ordering {
 return x <=> y;
 });
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
constexpr std::partial_ordering IteratorBase<Iter, Item>::partial_cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::partial_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept {
 return __private::iter_compare<std::partial_ordering, Item, OtherItem>(
 static_cast<Iter&&>(*this), ::sus::move(other).into_iter(),
 ::sus::move(cmp));
}

template <class Iter, class Item>
template <class B>
 requires(::sus::construct::Default &&
 Extend<B, Item>)
constexpr sus::Tuple<B, B> IteratorBase<Iter, Item>::partition(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept {
 B left;
 B right;

auto extend = [&pred, &left, &right](Item&& i) mutable {
 if (::sus::fn::call_mut(
 pred, static_cast<const std::remove_reference_t<Item>&>(i))) {

left.extend(::sus::Option<Item>(::sus::forward<Item>(i)));
 } else {
 right.extend(::sus::Option<Item>(::sus::forward<Item>(i)));
 }
 };

static_cast<Iter&&>(*this).for_each(extend);
 return sus::tuple(sus::move(left), sus::move(right));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::peekable() && noexcept {
 using Peekable = Peekable<Iter>;
 return Peekable(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Option<usize> IteratorBase<Iter, Item>::position(
 ::sus::fn::FnMut<bool(Item&&)> auto pred) noexcept {
 usize pos;
 while (true) {
 Option<Item> o = as_subclass_mut().next();
 if (o.is_none()) return Option<usize>();
 if (::sus::fn::call_mut(
 pred, ::sus::move(o).unwrap_unchecked(::sus::marker::unsafe_fn)))
 return Option<usize>(pos);
 pos += 1u;
 }
}

template <class Iter, class Item>
template <class P>
 requires(Product<P, Item>)
constexpr P IteratorBase<Iter, Item>::product() && noexcept {
 return P::from_product(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr IteratorRange<Iter> IteratorBase<Iter, Item>::range() && noexcept {
 return IteratorRange<Iter>(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <::sus::fn::FnMut<Item(Item, Item)> F, int&..., class R>
 requires(!std::is_reference_v<Item> ||
 std::is_reference_v<R>)
constexpr Option<Item> IteratorBase<Iter, Item>::reduce(F f) && noexcept {
 Option<Item> first = as_subclass_mut().next();
 if (first.is_some()) {
 first = Option<Item>(static_cast<Iter&&>(*this).template fold<Item>(
 ::sus::move(first).unwrap_unchecked(::sus::marker::unsafe_fn),
 ::sus::move(f)));
 }
 return first;
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::rev() && noexcept
 requires(DoubleEndedIterator<Iter, Item>)
{
 using Reverse = Reverse<Iter>;
 return Reverse(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Option<Item> IteratorBase<Iter, Item>::rfind(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) noexcept
 requires(DoubleEndedIterator<Iter, Item>)
{
 while (true) {
 Option<Item> o = as_subclass_mut().next_back();
 if (o.is_none() || ::sus::fn::call_mut(pred, o.as_value())) return o;
 }
}

template <class Iter, class Item>
template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, Item)> F>
 requires(DoubleEndedIterator<Iter, Item> &&
 std::convertible_to<std::invoke_result_t<F&, B &&, Item &&>, B> &&
 (!std::is_reference_v ||
 std::is_reference_v<std::invoke_result_t<F&, B &&, Item &&>>))
constexpr B IteratorBase<Iter, Item>::rfold(B init, F f) && noexcept {
 while (true) {
 if (Option<Item> o = as_subclass_mut().next_back(); o.is_none())
 return init;
 else
 init = ::sus::fn::call_mut(f, ::sus::move(init), sus::move(o).unwrap());
 }
}

template <class Iter, class Item>
constexpr Option<usize> IteratorBase<Iter, Item>::rposition(
 ::sus::fn::FnMut<bool(Item&&)> auto pred) noexcept
 requires(DoubleEndedIterator<Iter, Item> &&
 ExactSizeIterator<Iter, Item>)
{
 usize pos = as_subclass().exact_size_hint();
 while (true) {
 Option<Item> o = as_subclass_mut().next_back();
 if (o.is_none()) return Option<usize>();

pos -= 1u;
 if (::sus::fn::call_mut(
 pred, ::sus::move(o).unwrap_unchecked(::sus::marker::unsafe_fn)))
 return Option<usize>(pos);
 }
}

template <class Iter, class Item>
template <class State, ::sus::fn::FnMut<::sus::fn::NonVoid(State&, Item&&)> F,
 int&..., class R,
 class InnerR>
 requires(::sus::option::__private::IsOptionType<R>::value &&
 !std::is_reference_v<State>)
constexpr Iterator<InnerR> auto IteratorBase<Iter, Item>::scan(
 State initial_state, F f) && noexcept {
 using Scan = Scan<InnerR, State, Iter, F>;
 return Scan(::sus::move(initial_state), ::sus::move(f),
 static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::skip(
 usize n) && noexcept {
 using Skip = Skip<Iter>;
 return Skip(n, static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::skip_while(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept {
 using SkipWhile = SkipWhile<Iter, decltype(pred)>;
 return SkipWhile(::sus::move(pred), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::step_by(
 usize step) && noexcept {
 using StepBy = StepBy<Iter>;
 return StepBy(step, static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
 requires(::sus::cmp::StrongOrd<Item, OtherItem>)
constexpr std::strong_ordering IteratorBase<Iter, Item>::strong_cmp(
 Other&& other) && noexcept {
 return static_cast<Iter&&>(*this).strong_cmp_by(
 ::sus::move(other),
 [](const std::remove_reference_t<Item>& x,
 const std::remove_reference_t<OtherItem>& y) { return x <=> y; });
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
constexpr std::strong_ordering IteratorBase<Iter, Item>::strong_cmp_by(
 Other&& other,
 ::sus::fn::FnMut<std::strong_ordering(
 const std::remove_reference_t<Item>&,
 const std::remove_reference_t<OtherItem>&)> auto cmp) && noexcept {
 return __private::iter_compare<std::strong_ordering, Item, OtherItem>(
 static_cast<Iter&&>(*this), ::sus::move(other).into_iter(),
 ::sus::move(cmp));
}

template <class Iter, class Item>
template <class P>
 requires(Sum<P, Item>)
constexpr P IteratorBase<Iter, Item>::sum() && noexcept {
 return P::from_sum(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::take(
 usize n) && noexcept {
 using Take = Take<Iter>;
 return Take(n, static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr Iterator<Item> auto IteratorBase<Iter, Item>::take_while(
 ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
 pred) && noexcept {
 using TakeWhile = TakeWhile<Iter, decltype(pred)>;
 return TakeWhile(::sus::move(pred), static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, Item)> F, int&...,
 class R>
 requires(::sus::ops::Try<R> &&
 std::convertible_to<typename ::sus::ops::TryImpl<R>::Output, B>)
constexpr R IteratorBase<Iter, Item>::try_fold(B init, F f) noexcept {
 while (true) {
 if (Option<Item> o = as_subclass_mut().next(); o.is_none())
 return ::sus::ops::try_from_output<R>(::sus::move(init));
 else {
 R out = ::sus::fn::call_mut(f, ::sus::move(init), sus::move(o).unwrap());
 if (!::sus::ops::try_is_success(out)) return out;
 init = ::sus::ops::try_into_output(::sus::move(out));
 }
 }
}

template <class Iter, class Item>
template <class B, ::sus::fn::FnMut<::sus::fn::NonVoid(B, Item)> F, int&...,
 class R>
 requires(DoubleEndedIterator<Iter, Item> &&
 ::sus::ops::Try<R> &&
 std::convertible_to<typename ::sus::ops::TryImpl<R>::Output, B>)
constexpr R IteratorBase<Iter, Item>::try_rfold(B init, F f) noexcept {
 while (true) {
 if (Option<Item> o = as_subclass_mut().next_back(); o.is_none())
 return ::sus::ops::try_from_output<R>(::sus::move(init));
 else {
 R out = ::sus::fn::call_mut(f, ::sus::move(init), sus::move(o).unwrap());
 if (!::sus::ops::try_is_success(out)) return out;
 init = ::sus::ops::try_into_output(::sus::move(out));
 }
 }
}

template <class Iter, class Item>
template <::sus::fn::FnMut<::sus::fn::NonVoid(Item)> F, int&..., class R>
 requires(::sus::ops::TryDefault<R>)
constexpr R IteratorBase<Iter, Item>::try_for_each(F f) noexcept {

R out = ::sus::ops::try_from_default<R>();
 while (true) {
 if (Option<Item> o = as_subclass_mut().next(); o.is_none()) {
 break;
 } else {
 R test = ::sus::fn::call_mut(f, std::move(o).unwrap());
 if (!::sus::ops::try_is_success(test)) {
 out = ::sus::move(test);
 break;
 }
 }
 }
 return out;
}

template <class Iter, class Item>
template <class CollectionA, class CollectionB, int&..., class ItemA,
 class ItemB>
 requires(::sus::option::__private::IsTupleOfSizeTwo<Item>::value &&
 ::sus::construct::Default<CollectionA> &&
 ::sus::construct::Default<CollectionB> &&
 Extend<CollectionA, ItemA> &&
 Extend<CollectionB, ItemB>)
sus::Tuple<CollectionA, CollectionB> constexpr IteratorBase<
 Iter, Item>::unzip() && noexcept {
 auto out = sus::Tuple<CollectionA, CollectionB>();
 out.template extend<ItemA, ItemB>(static_cast<Iter&&>(*this));
 return out;
}

template <class Iter, class Item>
template <IntoIteratorAny Other, int&..., class OtherItem>
constexpr Iterator<sus::Tuple<Item, OtherItem>> auto
IteratorBase<Iter, Item>::zip(Other&& other) && noexcept {
 using Zip = Zip<Iter, IntoIteratorOutputType<Other>>;
 return Zip(
 sus::tuple(static_cast<Iter&&>(*this), sus::move(other).into_iter()));
}

template <class Iter, class Item>
template <FromIterator<Item> C>
constexpr C IteratorBase<Iter, Item>::collect() && noexcept {
 return ::sus::iter::from_iter<C>(static_cast<Iter&&>(*this));
}

template <class Iter, class Item>
constexpr ::sus::collections::Vec<Item>
IteratorBase<Iter, Item>::collect_vec() && noexcept {
 return ::sus::iter::from_iter<::sus::collections::Vec<Item>>(
 static_cast<Iter&&>(*this));
}

}

namespace sus::collections {

template <class ItemT, size_t N>
struct [[nodiscard]] ArrayIntoIter final
 : public ::sus::iter::IteratorBase<ArrayIntoIter<ItemT, N>, ItemT> {
 public:
 using Item = ItemT;
 constexpr static usize Size = N;

explicit constexpr ArrayIntoIter(Array<Item, N>&& array) noexcept
 : array_(::sus::move(array)) {}

constexpr ArrayIntoIter clone() const noexcept
 requires(::sus::mem::Clone<Array<ItemT, N>>)
 {
 return ArrayIntoIter(::sus::clone(array_), front_index_, back_index_);
 }

constexpr Option<Item> next() noexcept {
 if constexpr (N == 0) {
 return Option<Item>();
 } else {
 if (front_index_ == back_index_) [[unlikely]]
 return Option<Item>();

Item& item = array_.get_unchecked_mut(
 ::sus::marker::unsafe_fn,
 ::sus::mem::replace(front_index_, front_index_ + 1_usize));
 return Option<Item>(move(item));
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 ::sus::num::usize remaining = back_index_ - front_index_;
 return ::sus::iter::SizeHint(remaining,
 ::sus::Option<::sus::num::usize>(remaining));
 }

constexpr Option<Item> next_back() noexcept {
 if constexpr (N == 0) {
 return Option<Item>();
 } else {
 if (front_index_ == back_index_) [[unlikely]]
 return Option<Item>();

back_index_ -= 1u;
 Item& item =
 array_.get_unchecked_mut(::sus::marker::unsafe_fn, back_index_);
 return Option<Item>(move(item));
 }
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return back_index_ - front_index_;
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:
 constexpr ArrayIntoIter(Array<Item, N>&& array, usize front,
 usize back) noexcept
 : array_(::sus::move(array)), front_index_(front), back_index_(back) {}

Array<Item, N> array_;
 usize front_index_ = 0_usize;
 usize back_index_ = N;

};

}

static_assert(1 == 0 || 1 == 1);

namespace sus::iter {

struct IterRefCounter;

struct [[clang::trivial_abi]] IterRef final {
  constexpr IterRef(usize* ptr) noexcept : count_ptr_(ptr) { inc(); }
  constexpr ~IterRef() noexcept { dec(); }
  constexpr IterRef(const IterRef& rhs) noexcept : count_ptr_(rhs.count_ptr_) {
    inc();
  }
  constexpr IterRef& operator=(const IterRef& rhs) noexcept {
    dec();
    count_ptr_ = rhs.count_ptr_;
    inc();
    return *this;
  }
  constexpr IterRef(IterRef&& rhs) noexcept
      : count_ptr_(::sus::mem::replace(rhs.count_ptr_, nullptr)) {}
  constexpr IterRef& operator=(IterRef&& rhs) noexcept {
    dec();
    count_ptr_ = ::sus::mem::replace(rhs.count_ptr_, nullptr);
    return *this;
  }

constexpr IterRefCounter to_view() const noexcept;

private:
  usize* count_ptr_;

constexpr void inc() {

if (count_ptr_) *count_ptr_ += 1u;
  }
  constexpr void dec() {
    if (count_ptr_) *count_ptr_ -= 1u;
  }

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(count_ptr_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

struct [[clang::trivial_abi]] IterRefCounter final {
  static constexpr IterRefCounter for_owner() noexcept {
    return IterRefCounter(FOR_OWNER, 0_usize);
  }
  static constexpr IterRefCounter empty_for_view() noexcept {
    return IterRefCounter(FOR_VIEW, nullptr);
  }

constexpr IterRef to_iter_from_owner() const noexcept {
    return IterRef(&count);
  }

constexpr IterRef to_iter_from_view() const noexcept {
    return IterRef(count_ptr);
  }

constexpr IterRefCounter to_view_from_owner() const noexcept {
    return IterRefCounter(FOR_VIEW, &count);
  }

constexpr IterRefCounter to_view_from_view() const noexcept {

return IterRefCounter(FOR_VIEW, count_ptr);
  }

constexpr usize count_from_owner() const noexcept { return count; }

constexpr IterRefCounter take_for_owner() & noexcept {
    return IterRefCounter(FOR_OWNER, ::sus::mem::replace(count, 0u));
  }

constexpr IterRefCounter take_for_view() & noexcept {
    return IterRefCounter(FOR_VIEW, ::sus::mem::replace(count_ptr, nullptr));
  }

private:
  friend struct IterRef;

enum ForOwner { FOR_OWNER };
  constexpr IterRefCounter(ForOwner, usize count) noexcept : count(count) {}
  enum ForView { FOR_VIEW };
  constexpr IterRefCounter(ForView, usize* ptr) noexcept : count_ptr(ptr) {}

union {

mutable usize count;

usize* count_ptr;
  };

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(count), decltype(count_ptr)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

constexpr IterRefCounter IterRef::to_view() const noexcept {
  return IterRefCounter(IterRefCounter::FOR_VIEW, count_ptr_);
}

static_assert(sus::mem::Copy<IterRefCounter>);
static_assert(sus::mem::Move<IterRefCounter>);
static_assert(sus::mem::relocate_by_memcpy<IterRefCounter>);

}

namespace sus::ptr {

template <class T>
 requires(!std::is_const_v<T>)
void copy_nonoverlapping(::sus::marker::UnsafeFnMarker, const T* src, T* dst,
 ::sus::num::usize count) noexcept {
 ;
 ;

;
                                                                     ;

;
 if constexpr (::sus::mem::size_of<T>() > 1) {
 auto bytes = count.checked_mul(::sus::mem::size_of<T>()).expect("overflow");
 memcpy(dst, src, bytes);
 } else {
 memcpy(dst, src, count);
 }
}

template <class T>
 requires(!std::is_const_v<T>)
void copy(::sus::marker::UnsafeFnMarker, const T* src, T* dst,
 ::sus::num::usize count) noexcept {
 ;
 ;

;
 ;
 if constexpr (::sus::mem::size_of<T>() > 1) {
 auto bytes = count.checked_mul(::sus::mem::size_of<T>()).expect("overflow");
 memmove(dst, src, bytes);
 } else {
 memmove(dst, src, count);
 }
}

}

namespace sus::cmp::__private {

template <class T, class U = T>
concept VoidOrEq =
 (std::is_void_v<T> && std::is_void_v) || ::sus::cmp::Eq<T, U>;

template <class T, class U = T>
concept VoidOrOrd =
 (std::is_void_v<T> && std::is_void_v) || ::sus::cmp::StrongOrd<T, U>;

template <class T, class U = T>
concept VoidOrWeakOrd =
 (std::is_void_v<T> && std::is_void_v) || ::sus::cmp::Ord<T, U>;

template <class T, class U = T>
concept VoidOrPartialOrd =
 (std::is_void_v<T> && std::is_void_v) || ::sus::cmp::PartialOrd<T, U>;

}

namespace sus::iter {

using ::sus::option::Option;

template <class ItemT>
class Once;

template <class Item>
constexpr inline Once<Item> once(Item o [[clang::lifetimebound]]) noexcept {
 return Once<Item>(::sus::forward<Item>(o));
}

template <class ItemT>
class [[nodiscard]] Once final : public IteratorBase<Once<ItemT>, ItemT> {
 public:
 using Item = ItemT;

constexpr Option<Item> next() noexcept { return single_.take(); }

constexpr SizeHint size_hint() const noexcept {
 ::sus::num::usize rem = single_.is_some() ? 1u : 0u;
 return SizeHint(rem, ::sus::Option<::sus::num::usize>(rem));
 }

constexpr Option<Item> next_back() noexcept { return single_.take(); }

constexpr usize exact_size_hint() const noexcept {
    return single_.is_some() ? 1u : 0u;
  }
  constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:
 friend constexpr Once<Item> sus::iter::once<Item>(Item o) noexcept;

constexpr Once(Item single [[clang::lifetimebound]])
 : single_(::sus::forward<Item>(single)) {}

Option<Item> single_;

};

}

namespace sus::result {

struct OkVoid {};

}

namespace sus::result::__private {

struct [[nodiscard]] OkVoidMarker {
  OkVoidMarker() = default;

template <class E>
 constexpr operator ::sus::result::Result<void, E>() const& noexcept {
 return Result<void, E>(::sus::result::OkVoid());
 }

template <class E>
 constexpr operator ::sus::result::Result<void, E>() && noexcept {
 return Result<void, E>(::sus::result::OkVoid());
 }

template <class E>
 constexpr ::sus::result::Result<void, E> construct() && noexcept {
 return ::sus::move(*this);
 }

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

template <class T>
struct [[nodiscard]] OkMarker {
 constexpr inline OkMarker(T&& value) : value(::sus::forward<T>(value)) {}

T&& value;

template <class U, class E>
 inline constexpr operator ::sus::result::Result<U, E>() const& noexcept {
 static_assert(
 std::convertible_to<::sus::mem::remove_rvalue_reference<T>, U>,
 "OkMarker(T) can't convert const T& to U for Result<U, E>. "
 "Note that this is a test-only code path for Gtest support. "
 "Typically the T object is consumed as an rvalue, consider using "
 "EXPECT_TRUE(a == b) if needed.");
 static_assert(std::convertible_to<T&&, U>,
 "OkMarker(T) can't convert T to U for Result<U, E>");
 static_assert(
 ::sus::construct::SafelyConstructibleFromReference<U, const T&>,
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The OkMarker's value type "
 "must match the Result's. For example a `Result<const i32&, E>` can "
 "not be constructed from an OkMarker holding `const i16&`, but it can "
 "be constructed from `i32&&`.");
 return Result<U, E>(U(value));
 }

template <class U, class E>
 inline constexpr operator ::sus::result::Result<U, E>() && noexcept {
 static_assert(std::convertible_to<T&&, U>,
 "OkMarker(T) can't convert T to U for Result<U, E>");
 static_assert(
 ::sus::construct::SafelyConstructibleFromReference<U, T&&>,
 "Unable to safely convert to a different reference type, as conversion "
 "would produce a reference to a temporary. The OkMarker's value type "
 "must match the Result's. For example a `Result<const i32&, E>` can "
 "not be constructed from an OkMarker holding `const i16&`, but it can "
 "be constructed from `i32&&`.");
 return Result<U, E>(::sus::forward<T>(value));
 }

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

template <class E>
struct [[nodiscard]] ErrMarker {
 constexpr inline ErrMarker(E&& value) : value(::sus::forward<E>(value)) {}

E&& value;

template <class T, class F>
 inline constexpr operator ::sus::result::Result<T, F>() const& noexcept {
 static_assert(
 std::convertible_to<::sus::mem::remove_rvalue_reference<E>, F>,
 "ErrMarker(T) can't convert const E& to F for Result<T, F>. "
 "Note that this is a test-only code path for Gtest support. "
 "Typically the T object is consumed as an rvalue, consider using "
 "EXPECT_TRUE(a == b) if needed.");
 static_assert(std::convertible_to<E&&, F>,
 "ErrMarker(E) can't convert E to F for Result<T, F>");
 return Result<T, F>::with_err(F(value));
 }

template <class T, class F>
 inline constexpr operator ::sus::result::Result<T, F>() && noexcept {
 static_assert(std::convertible_to<E&&, F>,
 "ErrMarker(E) can't convert E to F for Result<T, F>");
 return Result<T, F>::with_err(::sus::forward<E>(value));
 }

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

}

namespace sus::result::__private {

enum class ResultState { IsErr = 0, IsOk = 1, IsMoved = 2 };

}

namespace sus::result::__private {

enum WithT { kWithT };
enum WithE { kWithE };

template <class T, class E>
union Storage {
 constexpr Storage() {}

template <std::convertible_to<T> U>
 constexpr Storage(WithT, const U& t) noexcept
 requires(sus::mem::Copy<T>)
 : ok_(t) {}
 template <std::convertible_to<T> U>
 constexpr Storage(WithT, U&& t) noexcept : ok_(::sus::move(t)) {}
 constexpr Storage(WithE, const E& e) noexcept
 requires(sus::mem::Copy<E>)
 : err_(e) {}
 constexpr Storage(WithE, E&& e) noexcept : err_(::sus::move(e)) {}

constexpr ~Storage()
 requires(std::is_trivially_destructible_v<T> &&
 std::is_trivially_destructible_v<E>)
 = default;
 constexpr ~Storage()
 requires(!(std::is_trivially_destructible_v<T> &&
 std::is_trivially_destructible_v<E>))
 {

}

constexpr Storage(const Storage&) noexcept
 requires(std::is_trivially_copy_constructible_v<T> &&
 std::is_trivially_copy_constructible_v<E>)
 = default;
 constexpr Storage& operator=(const Storage&)
 requires(std::is_trivially_copy_assignable_v<T> &&
 std::is_trivially_copy_assignable_v<E>)
 = default;

constexpr Storage(Storage&&)
 requires(std::is_trivially_move_constructible_v<T> &&
 std::is_trivially_move_constructible_v<E>)
 = default;
 constexpr Storage& operator=(Storage&&)
 requires(std::is_trivially_move_assignable_v<T> &&
 std::is_trivially_move_assignable_v<E>)
 = default;

constexpr inline void destroy_ok() noexcept { ok_.~T(); }
  constexpr inline void destroy_err() noexcept { err_.~E(); }

[[no_unique_address]] T ok_;
  [[no_unique_address]] E err_;
};

}

namespace sus {

namespace result {}
}

namespace sus::result {

using ::sus::cmp::__private::VoidOrEq;
using ::sus::cmp::__private::VoidOrOrd;
using ::sus::cmp::__private::VoidOrPartialOrd;
using ::sus::cmp::__private::VoidOrWeakOrd;
using ::sus::iter::Once;
using ::sus::mem::__private::IsTrivialCopyAssignOrRef;
using ::sus::mem::__private::IsTrivialCopyCtorOrRef;
using ::sus::mem::__private::IsTrivialDtorOrRef;
using ::sus::mem::__private::IsTrivialMoveAssignOrRef;
using ::sus::mem::__private::IsTrivialMoveCtorOrRef;
using ::sus::option::__private::StoragePointer;
using ::sus::result::__private::ResultState;
using ::sus::result::__private::Storage;

enum class State : bool {

Err = 0,

Ok = 1,
};
using State::Err;
using State::Ok;

template <class T, class E>
class [[nodiscard]] Result final {
 static_assert(!std::is_reference_v<E>,
 "A reference Error type is not supported.");
 static_assert(
 !std::is_rvalue_reference_v<T>,
 "`Option<T&&> is not supported, use Option<T&> or Option<const T&.");
 static_assert(!std::is_void_v<E>,
 "A void Error type is not supported. Use Option<T> instead.");

using TUnlessVoid = std::conditional_t<std::is_void_v<T>, OkVoid, T>;

public:
  using OkType = T;
  using ErrType = E;

explicit constexpr Result(OkVoid) noexcept
 requires(std::is_void_v<T>)
 : Result(WITH_OK) {}

explicit constexpr Result(const TUnlessVoid& t) noexcept
 requires(!std::is_void_v<T> &&
 !std::is_reference_v<T> &&
 ::sus::mem::Copy<T>)
 : Result(WITH_OK, t) {}

explicit constexpr Result(TUnlessVoid&& t) noexcept
 requires(!std::is_void_v<T> &&
 !std::is_reference_v<T> &&
 ::sus::mem::Move<T>)
 : Result(WITH_OK, move_ok_to_storage(t)) {}

template <std::convertible_to<TUnlessVoid> U>
 explicit constexpr Result(U&& t [[clang::lifetimebound]]) noexcept
 requires(!std::is_void_v<T> &&
 std::is_reference_v<T> &&
 sus::construct::SafelyConstructibleFromReference<T, U &&>)
 : Result(WITH_OK, move_ok_to_storage(t)) {}

static constexpr inline Result with_err(const E& e) noexcept
 requires(::sus::mem::Copy<E>)
 {
 return Result(WITH_ERR, e);
 }
 static constexpr inline Result with_err(E&& e) noexcept
 requires(::sus::mem::Move<E>)
 {
 return Result(WITH_ERR, ::sus::move(e));
 }

constexpr ~Result()
 requires((std::is_void_v<T> || IsTrivialDtorOrRef<T>) &&
 IsTrivialDtorOrRef<E>)
 = default;

constexpr inline ~Result() noexcept
    requires(

!((std::is_void_v<T> || IsTrivialDtorOrRef<T>) &&
 IsTrivialDtorOrRef<E>)

)
  {
    switch (state_) {
      case ResultState::IsMoved: break;
      case ResultState::IsOk: storage_.destroy_ok(); break;
      case ResultState::IsErr: storage_.destroy_err(); break;
    }
  }

constexpr Result(const Result&)
 requires((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E> &&
 (std::is_void_v<T> || IsTrivialCopyCtorOrRef<T>) &&
 IsTrivialCopyCtorOrRef<E>)
 = default;

constexpr Result(const Result& rhs) noexcept
    requires(

(std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E> &&
 !((std::is_void_v<T> || IsTrivialCopyCtorOrRef<T>) &&
 IsTrivialCopyCtorOrRef<E>)

)
 : state_(rhs.state_) {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (state_) {
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>)
 std::construct_at(&storage_.ok_, rhs.storage_.ok_);
 break;
 case ResultState::IsErr:
 std::construct_at(&storage_.err_, rhs.storage_.err_);
 break;
 case ResultState::IsMoved:

::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
    }
  }

constexpr Result(const Result&)
 requires(!((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E>))
 = delete;

constexpr Result& operator=(const Result& o)
 requires((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E> &&
 (std::is_void_v<T> || IsTrivialCopyAssignOrRef<T>) &&
 IsTrivialCopyAssignOrRef<E>)
 = default;

constexpr Result& operator=(const Result& o) noexcept
    requires(

(std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) && ::sus::mem::Copy<E> &&
 !((std::is_void_v<T> || IsTrivialCopyAssignOrRef<T>) &&
 IsTrivialCopyAssignOrRef<E>)

)
 {
 check(o.state_ != ResultState::IsMoved);
 switch (state_) {
 case ResultState::IsOk:
 switch (state_ = o.state_) {
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>) {
 storage_.ok_ = o.storage_.ok_;
 }
 break;
 case ResultState::IsErr:
 storage_.destroy_ok();
 std::construct_at(&storage_.err_, o.storage_.err_);
 break;

case ResultState::IsMoved:
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 break;
 case ResultState::IsErr:
 switch (state_ = o.state_) {
 case ResultState::IsErr: storage_.err_ = o.storage_.err_; break;
 case ResultState::IsOk:
 storage_.destroy_err();
 if constexpr (!std::is_void_v<T>)
 std::construct_at(&storage_.ok_, o.storage_.ok_);
 break;

case ResultState::IsMoved:
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 break;
 case ResultState::IsMoved:
 switch (state_ = o.state_) {
 case ResultState::IsErr:
 std::construct_at(&storage_.err_, o.storage_.err_);
 break;
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>)
 std::construct_at(&storage_.ok_, o.storage_.ok_);
 break;

case ResultState::IsMoved:
            ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
        }
        break;
    }
    return *this;
  }

constexpr Result& operator=(const Result&)
 requires(!((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E>))
 = delete;

constexpr Result(Result&&)
 requires((std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) &&
 ::sus::mem::Move<E> &&
 (std::is_void_v<T> || IsTrivialMoveCtorOrRef<T>) &&
 IsTrivialMoveCtorOrRef<E>)
 = default;

constexpr Result(Result&& rhs) noexcept
    requires(

(std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) && ::sus::mem::Move<E> &&
 !((std::is_void_v<T> || IsTrivialMoveCtorOrRef<T>) &&
 IsTrivialMoveCtorOrRef<E>)

)
      : state_(::sus::mem::replace(rhs.state_, ResultState::IsMoved)) {
    ::sus::check(state_ != ResultState::IsMoved);
    switch (state_) {
      case ResultState::IsOk:
        std::construct_at(&storage_.ok_, ::sus::move(rhs.storage_.ok_));
        break;
      case ResultState::IsErr:
        std::construct_at(&storage_.err_, ::sus::move(rhs.storage_.err_));
        break;
      case ResultState::IsMoved:

::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
    }
  }

constexpr Result(Result&&)
 requires(!((std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) &&
 ::sus::mem::Move<E>))
 = delete;

constexpr Result& operator=(Result&& o)
 requires((std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) &&
 ::sus::mem::Move<E> &&
 (std::is_void_v<T> || IsTrivialMoveAssignOrRef<T>) &&
 IsTrivialMoveAssignOrRef<E>)
 = default;

constexpr Result& operator=(Result&& o) noexcept
    requires(

(std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) && ::sus::mem::Move<E> &&
 !((std::is_void_v<T> || IsTrivialMoveAssignOrRef<T>) &&
 IsTrivialMoveAssignOrRef<E>)

)
  {
    check(o.state_ != ResultState::IsMoved);
    switch (state_) {
      case ResultState::IsOk:
        switch (state_ = ::sus::mem::replace(o.state_, ResultState::IsMoved)) {
          case ResultState::IsOk:
            storage_.ok_ = ::sus::move(o.storage_.ok_);
            break;
          case ResultState::IsErr:
            storage_.destroy_ok();
            std::construct_at(&storage_.err_, ::sus::move(o.storage_.err_));
            break;

case ResultState::IsMoved:
            ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
        }
        break;
      case ResultState::IsErr:
        switch (state_ = ::sus::mem::replace(o.state_, ResultState::IsMoved)) {
          case ResultState::IsErr:
            storage_.err_ = ::sus::move(o.storage_.err_);
            break;
          case ResultState::IsOk:
            storage_.destroy_err();
            std::construct_at(&storage_.ok_, ::sus::move(o.storage_.ok_));
            break;

case ResultState::IsMoved:
            ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
        }
        break;
      case ResultState::IsMoved:
        switch (state_ = ::sus::mem::replace(o.state_, ResultState::IsMoved)) {
          case ResultState::IsErr:
            std::construct_at(&storage_.err_, ::sus::move(o.storage_.err_));
            break;
          case ResultState::IsOk:
            std::construct_at(&storage_.ok_, ::sus::move(o.storage_.ok_));
            break;

case ResultState::IsMoved:
            ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
        }
        break;
    }
    return *this;
  }

constexpr Result& operator=(Result&& o)
 requires(!(std::is_void_v<T> || ::sus::mem::MoveOrRef<T>) ||
 !::sus::mem::Move<E>)
 = delete;

constexpr Result clone() const& noexcept
 requires((std::is_void_v<T> || ::sus::mem::Clone<T>) &&
 ::sus::mem::Clone<E> &&
 !((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E>))
 {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (state_) {
 case ResultState::IsOk:
 if constexpr (std::is_void_v<T>)
 return Result(WITH_OK);
 else
 return Result(WITH_OK, ::sus::clone(storage_.ok_));
 case ResultState::IsErr:
 return Result(WITH_ERR, ::sus::clone(storage_.err_));
 case ResultState::IsMoved: break;
 }

::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
  }

constexpr void clone_from(const Result& source) &
 requires((std::is_void_v<T> || ::sus::mem::Clone<T>) &&
 ::sus::mem::Clone<E> &&
 !((std::is_void_v<T> || ::sus::mem::CopyOrRef<T>) &&
 ::sus::mem::Copy<E>))
 {
 ::sus::check(source.state_ != ResultState::IsMoved);
 if (&source == this) [[unlikely]]
 return;
 if (state_ == source.state_) {
 switch (state_) {
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>)
 ::sus::clone_into(storage_.ok_, source.storage_.ok_);
 break;
 case ResultState::IsErr:
 ::sus::clone_into(storage_.err_, source.storage_.err_);
 break;
 case ResultState::IsMoved:
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 } else {
 *this = source.clone();
 }
 }

template <::sus::iter::Iterator<Result<T, E>> Iter>
 requires ::sus::iter::Product<T>
 static constexpr Result from_product(Iter&& it) noexcept {
 class IterUntilNone final
 : public ::sus::iter::IteratorBase<IterUntilNone, T> {
 public:
 IterUntilNone(Iter& iter, Option<E>& err) : iter_(iter), err_(err) {}

Option<T> next() noexcept {
 Option<Result<T, E>> next = iter_.next();
 Option<T> out;
 if (next.is_some()) {
 Result<T, E> r =
 ::sus::move(next).unwrap_unchecked(::sus::marker::unsafe_fn);
 if (r.is_err()) {
 err_ = ::sus::move(r).err();
 } else {
 out = ::sus::move(r).ok();
 }
 }
 return out;
 }
 ::sus::iter::SizeHint size_hint() const noexcept {
 return ::sus::iter::SizeHint(0u, iter_.size_hint().upper);
 }

private:
 Iter& iter_;
 Option<E>& err_;
 };
 static_assert(::sus::iter::Iterator<IterUntilNone, T>);

Option<E> err;
 auto out = Result(IterUntilNone(it, err).product());
 if (err.is_some()) {
 out = Result::with_err(
 ::sus::move(err).unwrap_unchecked(::sus::marker::unsafe_fn));
 }
 return out;
 }

template <::sus::iter::Iterator<Result<T, E>> Iter>
 requires ::sus::iter::Sum<T>
 static constexpr Result from_sum(Iter&& it) noexcept {
 class IterUntilNone final
 : public ::sus::iter::IteratorBase<IterUntilNone, T> {
 public:
 IterUntilNone(Iter& iter, Option<E>& err) : iter_(iter), err_(err) {}

private:
 Iter& iter_;
 Option<E>& err_;
 };
 static_assert(::sus::iter::Iterator<IterUntilNone, T>);

Option<E> err;
 auto out = Result(IterUntilNone(it, err).sum());
 if (err.is_some()) {
 out = Result::with_err(
 ::sus::move(err).unwrap_unchecked(::sus::marker::unsafe_fn));
 }
 return out;
 }

constexpr inline bool is_ok() const& noexcept {
    ::sus::check(state_ != ResultState::IsMoved);
    return state_ == ResultState::IsOk;
  }

constexpr inline bool is_err() const& noexcept {
    ::sus::check(state_ != ResultState::IsMoved);
    return state_ == ResultState::IsErr;
  }

constexpr inline operator State() const& noexcept {
 ::sus::check(state_ != ResultState::IsMoved);
 return static_cast<State>(state_);
 }

template <::sus::fn::FnOnce<::sus::fn::NonVoid(TUnlessVoid&&)> AndFn>
 requires(
 !std::is_void_v<T> &&
 __private::IsResultWithErrType<sus::fn::ReturnOnce<AndFn, T &&>, E>)
 constexpr sus::fn::ReturnOnce<AndFn, TUnlessVoid&&> and_then(
 AndFn op) && noexcept {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (::sus::mem::replace(state_, ResultState::IsMoved)) {
 case ResultState::IsOk:
 return ::sus::fn::call_once(
 ::sus::move(op), ::sus::mem::take_and_destruct(
 ::sus::marker::unsafe_fn, storage_.ok_));
 case ResultState::IsErr:
 return sus::fn::ReturnOnce<AndFn, T&&>::with_err(
 ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.err_));
 case ResultState::IsMoved: break;
 }

sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <::sus::fn::FnOnce<::sus::fn::NonVoid()> AndFn>
 requires(std::is_void_v<T> &&
 __private::IsResultWithErrType<sus::fn::ReturnOnce<AndFn>, E>)
 constexpr sus::fn::ReturnOnce<AndFn> and_then(AndFn op) && noexcept {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (::sus::mem::replace(state_, ResultState::IsMoved)) {
 case ResultState::IsOk: return ::sus::fn::call_once(::sus::move(op));
 case ResultState::IsErr:
 return sus::fn::ReturnOnce<AndFn>::with_err(
 ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.err_));
 case ResultState::IsMoved: break;
 }

sus::unreachable_unchecked(::sus::marker::unsafe_fn);
  }

constexpr inline Option<T> ok() && noexcept
 requires(!std::is_void_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (::sus::mem::replace(state_, ResultState::IsMoved)) {
 case ResultState::IsOk:

return Option<T>(static_cast<T>(::sus::mem::take_and_destruct(
 ::sus::marker::unsafe_fn, storage_.ok_)));
 case ResultState::IsErr: storage_.destroy_err(); return Option<T>();
 case ResultState::IsMoved: break;
 }

::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
  }

constexpr inline Option<E> err() && noexcept {
 ::sus::check(state_ != ResultState::IsMoved);
 switch (::sus::mem::replace(state_, ResultState::IsMoved)) {
 case ResultState::IsOk: storage_.destroy_ok(); return Option<E>();
 case ResultState::IsErr:
 return Option<E>(::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.err_));
 case ResultState::IsMoved: break;
 }

::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
  }

constexpr const std::remove_reference_t<TUnlessVoid>& as_value() const&
 requires(!std::is_void_v<T>)
 {
 if (state_ != ResultState::IsOk) [[unlikely]] {
 if (state_ == ResultState::IsErr) {
 if constexpr (fmt::is_formattable<E>::value) {
 panic_with_message(fmt::to_string(storage_.err_));
 } else {
 panic_with_message("Result has error state");
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 return storage_.ok_;
 }
 constexpr const std::remove_reference_t<TUnlessVoid>& as_value() && = delete;

constexpr std::remove_reference_t<TUnlessVoid>& as_value_mut() &
 requires(!std::is_void_v<T>)
 {
 if (state_ != ResultState::IsOk) [[unlikely]] {
 if (state_ == ResultState::IsErr) {
 if constexpr (fmt::is_formattable<E>::value) {
 panic_with_message(fmt::to_string(storage_.err_));
 } else {
 panic_with_message("Result has error state");
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 return storage_.ok_;
 }

constexpr const std::remove_reference_t<E>& as_err() const& {
 if (state_ != ResultState::IsErr) [[unlikely]] {
 if (state_ == ResultState::IsOk) {
 if constexpr (!std::is_void_v<T>) {
 if constexpr (fmt::is_formattable<T>::value) {
 panic_with_message(fmt::to_string(storage_.ok_));
 } else {
 panic_with_message("Result has ok state");
 }
 } else {
 panic_with_message("Result has ok state");
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 return storage_.err_;
 }
 constexpr const std::remove_reference_t<E>& as_err() && = delete;

constexpr inline T unwrap() && noexcept {
 ResultState was = ::sus::mem::replace(state_, ResultState::IsMoved);
 if (was != ResultState::IsOk) [[unlikely]] {
 if (was == ResultState::IsErr) {
 if constexpr (fmt::is_formattable<E>::value) {
 panic_with_message(fmt::to_string(storage_.err_));
 } else {
 panic_with_message("Result has error state");
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 if constexpr (!std::is_void_v<T>) {
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.ok_);
 }
 }

constexpr inline T expect(const char* msg) && noexcept {
 ResultState was = ::sus::mem::replace(state_, ResultState::IsMoved);
 if (was != ResultState::IsOk) [[unlikely]] {
 if (was == ResultState::IsErr) {
 if constexpr (fmt::is_formattable<E>::value) {
 panic_with_message(fmt::format("{}: {}", msg, storage_.err_));
 } else {
 panic_with_message(msg);
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 if constexpr (!std::is_void_v<T>) {
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.ok_);
 }
 }

constexpr T unwrap_or_default() && noexcept
 requires(!std::is_reference_v<T> &&
 (std::is_void_v<T> || ::sus::construct::Default<T>))
 {
 ResultState was = ::sus::mem::replace(state_, ResultState::IsMoved);
 check_with_message(
 was != ResultState::IsMoved,
 "called `Result::unwrap_or_default()` on a moved Result");
 if constexpr (!std::is_void_v<T>) {
 if (was == ResultState::IsOk) {
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.ok_);
 } else {
 return T();
 }
 }
 }

constexpr inline T unwrap_unchecked(
 ::sus::marker::UnsafeFnMarker) && noexcept {
 if (state_ != ResultState::IsOk) sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 state_ = ResultState::IsMoved;
 if constexpr (!std::is_void_v<T>) {
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.ok_);
 }
 }

constexpr inline E unwrap_err() && noexcept {
 ResultState was = ::sus::mem::replace(state_, ResultState::IsMoved);
 if (was != ResultState::IsErr) [[unlikely]] {
 if (was == ResultState::IsOk) {
 if constexpr (!std::is_void_v<T>) {
 if constexpr (fmt::is_formattable<T>::value) {
 panic_with_message(fmt::to_string(storage_.ok_));
 } else {
 panic_with_message("Result has ok state");
 }
 } else {
 panic_with_message("Result has ok state");
 }
 } else {
 panic_with_message("Result used after move");
 }
 }
 return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.err_);
 }

constexpr inline E unwrap_err_unchecked(
      ::sus::marker::UnsafeFnMarker) && noexcept {
    __builtin_assume(state_ == ResultState::IsErr);
    state_ = ResultState::IsMoved;
    return ::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
                                         storage_.err_);
  }

template <::sus::fn::FnOnce<T(E&&)> F>
 constexpr T unwrap_or_else(F&& op) && noexcept {
 if (is_ok()) {
 return ::sus::move(*this).unwrap_unchecked(::sus::marker::unsafe_fn);
 } else {
 return ::sus::fn::call_once(
 ::sus::move(op),
 ::sus::move(*this).unwrap_err_unchecked(::sus::marker::unsafe_fn));
 }
 }

constexpr ::sus::option::OptionIter<
 const std::remove_reference_t<TUnlessVoid>&>
 iter() const& noexcept
 requires(!std::is_void_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 if (state_ == ResultState::IsOk) {
 return ::sus::option::OptionIter<const std::remove_reference_t<T>&>(

Option<const std::remove_reference_t<T>&>(
 static_cast<const std::remove_reference_t<T>&>(storage_.ok_)));
 } else {
 return ::sus::option::OptionIter<const std::remove_reference_t<T>&>(
 Option<const std::remove_reference_t<T>&>());
 }
 }
 constexpr ::sus::option::OptionIter<
 const std::remove_reference_t<TUnlessVoid>&>
 iter() && noexcept
 requires(!std::is_void_v<T> && std::is_reference_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 if (::sus::mem::replace(state_, ResultState::IsMoved) ==
 ResultState::IsOk) {
 return ::sus::option::OptionIter<const std::remove_reference_t<T>&>(

Option<const std::remove_reference_t<T>&>(
 static_cast<const std::remove_reference_t<T>&>(storage_.ok_)));
 } else {
 storage_.destroy_err();
 return ::sus::option::OptionIter<const std::remove_reference_t<T>&>(
 Option<const std::remove_reference_t<T>&>());
 }
 }

constexpr ::sus::option::OptionIter<TUnlessVoid&> iter_mut() & noexcept
 requires(!std::is_void_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 if (state_ == ResultState::IsOk) {
 return ::sus::option::OptionIter<T&>(Option<T&>(storage_.ok_));
 } else {
 return ::sus::option::OptionIter<T&>(Option<T&>());
 }
 }
 constexpr ::sus::option::OptionIter<TUnlessVoid&> iter_mut() && noexcept
 requires(!std::is_void_v<T> &&
 std::is_reference_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 if (::sus::mem::replace(state_, ResultState::IsMoved) ==
 ResultState::IsOk) {
 return ::sus::option::OptionIter<T&>(Option<T&>(storage_.ok_));
 } else {
 storage_.destroy_err();
 return ::sus::option::OptionIter<T&>(Option<T&>());
 }
 }

constexpr ::sus::option::OptionIter<T> into_iter() && noexcept
 requires(!std::is_void_v<T>)
 {
 ::sus::check(state_ != ResultState::IsMoved);
 if (::sus::mem::replace(state_, ResultState::IsMoved) ==
 ResultState::IsOk) {
 return ::sus::option::OptionIter<T>(
 Option<T>(::sus::mem::take_and_destruct(::sus::marker::unsafe_fn,
 storage_.ok_)));
 } else {
 storage_.destroy_err();
 return ::sus::option::OptionIter<T>(Option<T>());
 }
 }

friend constexpr bool operator==(const Result& l, const Result& r) noexcept
 requires(VoidOrEq<T> && ::sus::cmp::Eq<E>)
 {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>)
 return r.is_ok() && l.storage_.ok_ == r.storage_.ok_;
 else
 return r.is_ok();
 case ResultState::IsErr:
 return r.is_err() && l.storage_.err_ == r.storage_.err_;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U, class F>
 requires(VoidOrEq<T, U> && ::sus::cmp::Eq<E, F>)
 friend constexpr bool operator==(const Result& l,
 const Result<U, F>& r) noexcept {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if constexpr (!std::is_void_v<T>)
 return r.is_ok() && l.storage_.ok_ == r.storage_.ok_;
 else
 return r.is_ok();
 case ResultState::IsErr:
 return r.is_err() && l.storage_.err_ == r.storage_.err_;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U, class F>
 requires(!(VoidOrEq<T, U> && ::sus::cmp::Eq<E, F>))
 friend constexpr bool operator==(const Result& l,
 const Result<U, F>& r) = delete;

friend constexpr std::strong_ordering operator<=>(const Result& l,
 const Result& r) noexcept
 requires(VoidOrOrd<T> && ::sus::cmp::StrongOrd<E>)
 {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::strong_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::strong_ordering::equivalent;
 } else {
 return std::strong_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::strong_order(l.storage_.err_, r.storage_.err_);
 else
 return std::strong_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U, class F>
 requires(VoidOrOrd<T, U> && ::sus::cmp::StrongOrd<E, F>)
 friend constexpr std::strong_ordering operator<=>(
 const Result& l, const Result<U, F>& r) noexcept {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::strong_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::strong_ordering::equivalent;
 } else {
 return std::strong_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::strong_order(l.storage_.err_, r.storage_.err_);
 else
 return std::strong_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

friend constexpr std::weak_ordering operator<=>(const Result& l,
 const Result& r) noexcept
 requires((!VoidOrOrd<T> || !::sus::cmp::StrongOrd<E>) && VoidOrWeakOrd<T> &&
 ::sus::cmp::Ord<E>)
 {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::weak_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::weak_ordering::equivalent;
 } else {
 return std::weak_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::weak_order(l.storage_.err_, r.storage_.err_);
 else
 return std::weak_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U, class F>
 requires((!VoidOrOrd<T, U> || !::sus::cmp::StrongOrd<E, F>) &&
 VoidOrWeakOrd<T, U> && ::sus::cmp::Ord<E, F>)
 friend constexpr std::weak_ordering operator<=>(
 const Result& l, const Result<U, F>& r) noexcept {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::weak_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::weak_ordering::equivalent;
 } else {
 return std::weak_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::weak_order(l.storage_.err_, r.storage_.err_);
 else
 return std::weak_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

friend constexpr std::partial_ordering operator<=>(const Result& l,
 const Result& r) noexcept
 requires((!VoidOrWeakOrd<T> || !::sus::cmp::Ord<E>) &&
 VoidOrPartialOrd<T> && ::sus::cmp::PartialOrd<E>)
 {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::partial_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::partial_ordering::equivalent;
 } else {
 return std::partial_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::partial_order(l.storage_.err_, r.storage_.err_);
 else
 return std::partial_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }
 template <class U, class F>
 requires((!VoidOrWeakOrd<T, U> || !::sus::cmp::Ord<E, F>) &&
 VoidOrPartialOrd<T, U> && ::sus::cmp::PartialOrd<E, F>)
 friend constexpr std::partial_ordering operator<=>(
 const Result& l, const Result<U, F>& r) noexcept {
 ::sus::check(l.state_ != ResultState::IsMoved);
 switch (l.state_) {
 case ResultState::IsOk:
 if (r.is_ok()) {
 if constexpr (!std::is_void_v<T>)
 return std::partial_order(l.storage_.ok_, r.storage_.ok_);
 else
 return std::partial_ordering::equivalent;
 } else {
 return std::partial_ordering::greater;
 }
 case ResultState::IsErr:
 if (r.is_err())
 return std::partial_order(l.storage_.err_, r.storage_.err_);
 else
 return std::partial_ordering::less;
 case ResultState::IsMoved: break;
 }
 ::sus::unreachable_unchecked(::sus::marker::unsafe_fn);
 }

template <class U, class F>
 requires(!VoidOrPartialOrd<T, U> || !::sus::cmp::PartialOrd<E, F>)
 friend constexpr auto operator<=>(const Result& l,
 const Result<U, F>& r) noexcept = delete;

private:
 template <class U, class V>
 friend class Result;

template <class U>
 static constexpr inline decltype(auto) copy_ok_to_storage(const U& t) {
 if constexpr (std::is_reference_v<T>)
 return StoragePointer<T>(t);
 else
 return t;
 }

template <class U>
 static constexpr inline decltype(auto) move_ok_to_storage(U&& t) {
 if constexpr (std::is_reference_v<T>)
 return StoragePointer<T>(t);
 else
 return ::sus::move(t);
 }

enum WithOk { WITH_OK };
 constexpr inline Result(WithOk) noexcept
 requires(std::is_void_v<T>)
 : storage_(), state_(ResultState::IsOk) {}
 template <std::convertible_to<T> U>
 constexpr inline Result(WithOk, const U& t) noexcept
 : storage_(__private::kWithT, t), state_(ResultState::IsOk) {}
 template <std::convertible_to<T> U>
 constexpr inline Result(WithOk, U&& t) noexcept
 requires(::sus::mem::Move<T>)
 : storage_(__private::kWithT, ::sus::move(t)),
 state_(ResultState::IsOk) {}

enum WithErr { WITH_ERR };
 constexpr inline Result(WithErr, const E& e) noexcept
 : storage_(__private::kWithE, e), state_(ResultState::IsErr) {}
 constexpr inline Result(WithErr, E&& e) noexcept
 requires(::sus::mem::Move<E>)
 : storage_(__private::kWithE, ::sus::move(e)),
 state_(ResultState::IsErr) {}

struct VoidStorage {};
 using OkStorageType =
 std::conditional_t<std::is_reference_v<T>, StoragePointer<T>,
 std::conditional_t<std::is_void_v<T>, VoidStorage, T>>;

[[no_unique_address]] Storage<OkStorageType, E> storage_;
 ResultState state_;

};

using sus::iter::begin;

using sus::iter::end;

template <class T>
[[nodiscard]] inline constexpr auto ok(T&& t [[clang::lifetimebound]]) noexcept {
 return __private::OkMarker<T&&>(::sus::forward<T>(t));
}

[[nodiscard]] inline constexpr auto ok() noexcept {
  return __private::OkVoidMarker();
}

template <class E>
[[nodiscard]] inline constexpr auto err(E&& e [[clang::lifetimebound]]) noexcept {
 return __private::ErrMarker<E&&>(::sus::forward<E>(e));
}

}

template <class T, class E>
 requires(!std::is_void_v<T>)
struct sus::ops::TryImpl<::sus::result::Result<T, E>> {
 using Output = T;
 template <class U>
 using RemapOutput = ::sus::result::Result<U, E>;
 constexpr static bool is_success(const ::sus::result::Result<T, E>& t) {
 return t.is_ok();
 }
 constexpr static Output into_output(::sus::result::Result<T, E> t) {

return ::sus::move(t).unwrap_unchecked(::sus::marker::unsafe_fn);
 }
 constexpr static ::sus::result::Result<T, E> from_output(Output t) {
 return ::sus::result::Result<T, E>(::sus::move(t));
 }
 template <class U>
 constexpr static ::sus::result::Result<T, E> preserve_error(
 ::sus::result::Result<U, E> t) noexcept {

return ::sus::result::Result<T, E>::with_err(
 ::sus::move(t).unwrap_err_unchecked(::sus::marker::unsafe_fn));
 }

constexpr static ::sus::result::Result<T, E> from_default() noexcept
 requires(sus::construct::Default<T>)
 {
 return ::sus::result::Result<T, E>(T());
 }
};

template <class E>
struct sus::ops::TryImpl<::sus::result::Result<void, E>> {
 using Output = void;
 template <class U>
 using RemapOutput = ::sus::result::Result<U, E>;
 constexpr static bool is_success(
 const ::sus::result::Result<void, E>& t) noexcept {
 return t.is_ok();
 }
 constexpr static void into_output(::sus::result::Result<void, E> t) noexcept {
 }
 constexpr static ::sus::result::Result<void, E> preserve_error(
 ::sus::result::Result<void, E> t) noexcept {
 ::sus::move(t);
 }

constexpr static ::sus::result::Result<void, E> from_default() noexcept {
 return ::sus::result::Result<void, E>(::sus::result::OkVoid());
 }
};

template <class T, class E>
struct sus::iter::FromIteratorImpl<::sus::result::Result<T, E>> {

template <class IntoIter, int&...,
 class Iter =
 std::decay_t<decltype(std::declval<IntoIter&&>().into_iter())>,
 class Item = typename Iter::Item,
 class U = ::sus::result::__private::IsResultType<Item>::ok_type,
 class F = ::sus::result::__private::IsResultType<Item>::err_type>
 requires(::sus::result::__private::IsResult<Item> && std::same_as<E, F> &&
 ::sus::iter::IntoIterator<IntoIter, ::sus::result::Result<U, E>>)
 static constexpr ::sus::result::Result<T, E> from_iter(
 IntoIter&& result_iter) noexcept
 requires(!std::is_void_v<T> && !std::is_reference_v<T> &&
 ::sus::iter::FromIterator<T, U>)
 {
 struct Unwrapper final : public ::sus::iter::IteratorBase<Unwrapper, U> {
 constexpr Unwrapper(Iter&& iter, Option<E>& err) : iter(iter), err(err) {}

constexpr Option next() noexcept {
 Option<::sus::result::Result<U, E>> try_item = iter.next();
 if (try_item.is_none()) return Option();
 ::sus::result::Result<U, E> result =
 ::sus::move(try_item).unwrap_unchecked(::sus::marker::unsafe_fn);
 if (result.is_ok())
 return Option(
 ::sus::move(result).unwrap_unchecked(::sus::marker::unsafe_fn));
 err.insert(
 ::sus::move(result).unwrap_err_unchecked(::sus::marker::unsafe_fn));
 return Option();
 }
 constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 return ::sus::iter::SizeHint(0u, iter.size_hint().upper);
 }

Iter& iter;
 Option<E>& err;
 };

auto err = Option<E>();
 auto iter = Unwrapper(::sus::move(result_iter).into_iter(), err);
 auto out = ::sus::result::Result<T, E>(
 ::sus::iter::from_iter<T>(::sus::move(iter)));
 if (err.is_some())
 out = ::sus::result::Result<T, E>::with_err(::sus::move(err).unwrap());
 return out;
 }
};

template <class T, class E>
struct std::hash<::sus::result::Result<T, E>> {
 auto operator()(const ::sus::result::Result<T, E>& u) const noexcept {
 if (u.is_ok())
 return std::hash<T>()(u.as_value());
 else
 return std::hash<T>()(u.as_err());
 }
};
template <class T, class E>
 requires(::sus::cmp::Eq<::sus::result::Result<T, E>>)
struct std::equal_to<::sus::result::Result<T, E>> {
 constexpr auto operator()(
 const ::sus::result::Result<T, E>& l,
 const ::sus::result::Result<T, E>& r) const noexcept {
 return l == r;
 }
};

template <class T, class E, class Char>
struct fmt::formatter<::sus::result::Result<T, E>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_ok_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::result::Result<T, E>& t,
 FormatContext& ctx) const {
 auto out = ctx.out();
 if (t.is_err()) {
 out = fmt::format_to(ctx.out(), "Err(");
 ctx.advance_to(out);
 out = underlying_err_.format(t.as_err(), ctx);
 } else {
 out = fmt::format_to(out, "Ok(");
 ctx.advance_to(out);
 if constexpr (std::is_void_v<T>)
 out = underlying_ok_.format(ctx);
 else
 out = underlying_ok_.format(t.as_value(), ctx);
 }
 return fmt::format_to(out, ")");
 }

private:
 ::sus::string::__private::AnyOrVoidFormatter<T, Char> underlying_ok_;
 ::sus::string::__private::AnyFormatter<E, Char> underlying_err_;
};

namespace sus::result { using namespace ::sus::string::__private; template< class T , class E , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const Result <T, E>& value ) { static_assert(fmt::is_formattable<Result <T, E> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus {
using ::sus::result::Err;
using ::sus::result::err;
using ::sus::result::Ok;
using ::sus::result::ok;
using ::sus::result::Result;
}

namespace sus::num {

struct [[clang::trivial_abi]] i32 final {

int32_t primitive_value{0};

static constexpr auto MIN_PRIMITIVE = __private::min_value<int32_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<int32_t>();

static const i32 MIN;

static const i32 MAX;

static const u32 BITS;

constexpr inline i32() noexcept = default;

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32(S v) noexcept : primitive_value(v.primitive_value) {}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int32_t>())
explicit constexpr inline i32(P v) noexcept
 : primitive_value(static_cast<int32_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int32_t>())
constexpr inline i32(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int32_t>())
constexpr inline i32(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int32_t>())
constexpr inline i32(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int32_t>())
explicit constexpr inline i32(P v) noexcept
 : primitive_value(static_cast<int32_t>(v)) {}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32& operator=(S v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int32_t>())
constexpr inline i32& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 return i32(s);
}

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE) {
 if (s.primitive_value < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE) {
 if (s.primitive_value > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(s.primitive_value)));
}

template <Unsigned S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 return i32(s);
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < U::MAX_PRIMITIVE) {
 if (u.primitive_value > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(u.primitive_value)));
}

template <SignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 return i32(s);
}

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<S>()) {
 if (s < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<S>()) {
 if (s > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(s)));
}

template <class S>
 requires((SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() <= ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i32(static_cast<std::underlying_type_t<S>>(s));
}

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<D>()) {
 if (static_cast<D>(s) < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<D>()) {
 if (static_cast<D>(s) > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(s)));
}

template <UnsignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 return i32(s);
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value()) {
 if (u > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(u)));
}

template <class S>
 requires((UnsignedPrimitiveEnum<S> || UnsignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() < ::sus::mem::size_of<int32_t>())
__attribute__((pure)) static constexpr i32 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i32(static_cast<std::underlying_type_t<S>>(s));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<i32,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using D = std::underlying_type_t;
 using R = ::sus::result::Result<i32, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value<D>()) {
 if (static_cast<D>(u) > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i32(static_cast<int32_t>(u)));
}

static constexpr i32 from_product(
 ::sus::iter::Iterator<i32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i32(int32_t{1});
 for (i32 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr i32 from_sum(::sus::iter::Iterator<i32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i32(int32_t{0});
 for (i32 i : ::sus::move(it)) p += i;
 return p;
}

template <SignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<int32_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr int32_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const int32_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const int32_t* as_ptr() && noexcept = delete;

__attribute__((pure)) constexpr bool is_negative() const& noexcept {
 return primitive_value < 0;
}

__attribute__((pure)) constexpr bool is_positive() const& noexcept {
  return primitive_value > 0;
}

__attribute__((pure)) constexpr i32 signum() const& noexcept {
 if (primitive_value < 0)
 return int32_t{-1};
 else
 return int32_t{primitive_value != 0};
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i32 l, i32 r) noexcept = default;

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i32 l, Signed auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i32 l, SignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i32 l, i32 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i32 l, Signed auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i32 l, SignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline i32 operator-() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr inline i32 operator~() const& noexcept {
  return __private::into_signed(
      __private::unchecked_not(__private::into_unsigned(primitive_value)));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator+(
    i32 l, i32 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator+(
 i32 l, U r) noexcept {
 return l + i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator+(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator+(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator-(
    i32 l, i32 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator-(
 i32 l, U r) noexcept {
 return l - i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator-(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator-(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator*(
    i32 l, i32 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator*(
 i32 l, U r) noexcept {
 return l * i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator*(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator*(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator/(
    i32 l, i32 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int32_t>(l.primitive_value / r.primitive_value);
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator/(
 i32 l, U r) noexcept {
 return l / i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator/(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator/(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator%(
    i32 l, i32 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int32_t>(l.primitive_value % r.primitive_value);
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator%(
 i32 l, U r) noexcept {
 return l % i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator%(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator%(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator&(
 i32 l, i32 r) noexcept {
 return static_cast<int32_t>(l.primitive_value & r.primitive_value);
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator&(
 i32 l, U r) noexcept {
 return l & i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator&(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator&(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator|(
 i32 l, i32 r) noexcept {
 return static_cast<int32_t>(l.primitive_value | r.primitive_value);
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator|(
 i32 l, U r) noexcept {
 return l | i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator|(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator|(U l, i32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i32 operator^(
 i32 l, i32 r) noexcept {
 return static_cast<int32_t>(l.primitive_value ^ r.primitive_value);
}

template <std::convertible_to<i32> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i32 operator^(
 i32 l, U r) noexcept {
 return l ^ i32(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator^(i32 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i32>)
friend constexpr inline i32 operator^(U l, i32 r) noexcept = delete;

constexpr inline void operator+=(i32 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(i32 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(i32 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(i32 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(i32 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(i32 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(i32 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(i32 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator>>=(u32 r) & noexcept {
  const auto out =
      __private::shr_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

__attribute__((pure)) constexpr inline i32 abs() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  if (primitive_value >= 0)
    return primitive_value;
  else
    return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr Option<i32> checked_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i32>(abs());
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(abs(), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i32 saturating_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MAX;
}

__attribute__((pure)) constexpr u32 unsigned_abs() const& noexcept {
  if (primitive_value >= 0) {
    return __private::into_unsigned(primitive_value);
  } else {
    const auto neg_plus_one =
        __private::unchecked_add(primitive_value, int32_t{1});
    const auto pos_minus_one =
        __private::into_unsigned(__private::unchecked_neg(neg_plus_one));
    return __private::unchecked_add(pos_minus_one, decltype(pos_minus_one){1});
  }
}

__attribute__((pure)) constexpr i32 wrapping_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MIN;
}

__attribute__((pure)) constexpr u32 abs_diff(i32 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return __private::sub_with_unsigned_positive_result(primitive_value,
                                                        other.primitive_value);
  } else {
    return __private::sub_with_unsigned_positive_result(other.primitive_value,
                                                        primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i32> checked_add(i32 rhs) const& noexcept {
 const auto out =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

__attribute__((pure)) constexpr Option<i32> checked_add_unsigned(
 u32 rhs) const& noexcept {
 const auto out = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add(i32 rhs) const& noexcept {
 const auto r =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add_unsigned(
 u32 rhs) const& noexcept {
 const auto r = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

__attribute__((pure)) constexpr i32 saturating_add(i32 rhs) const& noexcept {
  return __private::saturating_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 saturating_add_unsigned(
    u32 rhs) const& noexcept {
  const auto r = __private::add_with_overflow_unsigned(primitive_value,
                                                       rhs.primitive_value);
  if (!r.overflow) [[likely]]
    return r.value;
  else
    return MAX;
}

__attribute__((pure)) inline constexpr i32 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              i32 rhs) const& noexcept {
  return __private::unchecked_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 wrapping_add(i32 rhs) const& noexcept {
  return __private::wrapping_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 wrapping_add_unsigned(u32 rhs) const& noexcept {
  return __private::add_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i32> checked_div(i32 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i32>();
 else
 return Option<i32>(
 __private::unchecked_div(primitive_value, rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::unchecked_div(primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i32 saturating_div(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {

return MAX;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i32 wrapping_div(i32 rhs) const& noexcept {

return MIN;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i32> checked_mul(i32 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_mul(i32 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i32 saturating_mul(i32 rhs) const& noexcept {
  return __private::saturating_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr inline i32 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                              i32 rhs) const& noexcept {
  return __private::unchecked_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 wrapping_mul(i32 rhs) const& noexcept {
  return __private::wrapping_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i32> checked_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i32>(__private::unchecked_neg(primitive_value));
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(__private::unchecked_neg(primitive_value), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i32 saturating_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MAX;
}

__attribute__((pure)) constexpr i32 wrapping_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MIN;
}

__attribute__((pure)) constexpr Option<i32> checked_rem(i32 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i32>();
 else
 return Option<i32>(
 static_cast<int32_t>(primitive_value % rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(int32_t{0}, true);
 } else {
 return Tuple(static_cast<int32_t>(primitive_value % rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr i32 wrapping_rem(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[likely]] {
 return int32_t{0};
 } else {
 return static_cast<int32_t>(primitive_value % rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr i32 div_euclid(i32 rhs) const& noexcept {

::sus::check(!__private::div_overflows(primitive_value, rhs.primitive_value));
  return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                               rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i32> checked_div_euclid(i32 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i32>();
 } else {
 return Option<i32>(__private::div_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div_euclid(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::div_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i32 wrapping_div_euclid(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return MIN;
  } else {
    return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i32 rem_euclid(i32 rhs) const& noexcept {

::sus::check(!__private::div_overflows(primitive_value, rhs.primitive_value));
  return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
                               rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i32> checked_rem_euclid(i32 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i32>();
 } else {
 return Option<i32>(__private::rem_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem_euclid(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(int32_t{0}, true);
  } else {
    return Tuple(__private::rem_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i32 wrapping_rem_euclid(i32 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return int32_t{0};
  } else {
    return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i32> checked_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i32 wrapping_shl(u32 rhs) const& noexcept {
  return __private::shl_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i32> checked_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i32 wrapping_shr(u32 rhs) const& noexcept {
  return __private::shr_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i32> checked_sub(i32 rhs) const& {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

__attribute__((pure)) constexpr Option<i32> checked_sub_unsigned(u32 rhs) const& {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub(i32 rhs) const& noexcept {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub_unsigned(
 const u32& rhs) const& noexcept {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i32 saturating_sub(i32 rhs) const& {
  return __private::saturating_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 saturating_sub_unsigned(const u32& rhs) const& {
  const auto out = __private::sub_with_overflow_unsigned(primitive_value,
                                                         rhs.primitive_value);
  if (!out.overflow) [[likely]]
    return out.value;
  else
    return MIN;
}

__attribute__((pure)) inline constexpr i32 unchecked_sub(::sus::marker::UnsafeFnMarker,
 i32 rhs) const& {
 return static_cast<int32_t>(primitive_value - rhs.primitive_value);
}

constexpr i32 wrapping_sub(i32 rhs) const& {
  return __private::wrapping_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i32 wrapping_sub_unsigned(const u32& rhs) const& {
  return __private::sub_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr i32 reverse_bits() const& noexcept {
  return __private::into_signed(
      __private::reverse_bits(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr i32 rotate_left(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_left(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i32 rotate_right(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_right(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i32 swap_bytes() const& noexcept {
  return __private::into_signed(
      __private::swap_bytes(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr inline i32 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

__attribute__((pure)) constexpr Option<i32> checked_pow(u32 rhs) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, rhs.primitive_value);

if (!out.overflow) [[likely]]
 return Option<i32>(out.value);
 else
 return Option<i32>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i32, bool>>
__attribute__((pure)) constexpr Tuple overflowing_pow(u32 exp) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, exp.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i32 wrapping_pow(u32 exp) const& noexcept {
  return __private::wrapping_pow(primitive_value, exp.primitive_value);
}

__attribute__((pure)) constexpr Option<u32> checked_log2() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 uint32_t zeros = __private::leading_zeros_nonzero(
 ::sus::marker::unsafe_fn, __private::into_unsigned(primitive_value));
 return Option<u32>(u32(__private::num_bits<int32_t>()) - 1_u32 -
 u32(zeros));
 }
}

__attribute__((pure)) constexpr u32 log2() const& noexcept {

return checked_log2().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log10() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 return Option<u32>(__private::int_log10::i32(primitive_value));
 }
}

__attribute__((pure)) constexpr u32 log10() const& noexcept {

return checked_log10().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log(i32 base) const& noexcept {
 if (primitive_value <= 0 || base.primitive_value <= 1) [[unlikely]] {
 return Option<u32>();
 } else {
 auto n = uint32_t{0};
 auto r = primitive_value;
 const auto b = base.primitive_value;
 while (r >= b) {
 r /= b;
 n += 1u;
 }
 return Option<u32>(n);
 }
}

__attribute__((pure)) constexpr u32 log(i32 base) const& noexcept {
  return checked_log(base).unwrap();
}

__attribute__((pure)) static constexpr i32 from_be(i32 x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) static constexpr i32 from_le(i32 x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr i32 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr i32 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int32_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int32_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int32_t>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static constexpr i32 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int32_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i32 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int32_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i32 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int32_t>()>&
 bytes) noexcept;

};

inline constexpr i32 i32::MIN = i32(i32::MIN_PRIMITIVE);
inline constexpr i32 i32::MAX = i32(i32::MAX_PRIMITIVE);
inline constexpr u32 i32::BITS = u32(__private::num_bits<int32_t>());

struct [[clang::trivial_abi]] i8 final {

int8_t primitive_value{0};

static constexpr auto MIN_PRIMITIVE = __private::min_value<int8_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<int8_t>();

static const i8 MIN;

static const i8 MAX;

static const u32 BITS;

constexpr inline i8() noexcept = default;

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8(S v) noexcept : primitive_value(v.primitive_value) {}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int8_t>())
explicit constexpr inline i8(P v) noexcept
 : primitive_value(static_cast<int8_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int8_t>())
constexpr inline i8(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int8_t>())
constexpr inline i8(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int8_t>())
constexpr inline i8(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int8_t>())
explicit constexpr inline i8(P v) noexcept
 : primitive_value(static_cast<int8_t>(v)) {}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8& operator=(S v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int8_t>())
constexpr inline i8& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 return i8(s);
}

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE) {
 if (s.primitive_value < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE) {
 if (s.primitive_value > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(s.primitive_value)));
}

template <Unsigned S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 return i8(s);
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < U::MAX_PRIMITIVE) {
 if (u.primitive_value > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(u.primitive_value)));
}

template <SignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 return i8(s);
}

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<S>()) {
 if (s < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<S>()) {
 if (s > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(s)));
}

template <class S>
 requires((SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() <= ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i8(static_cast<std::underlying_type_t<S>>(s));
}

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<D>()) {
 if (static_cast<D>(s) < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<D>()) {
 if (static_cast<D>(s) > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(s)));
}

template <UnsignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 return i8(s);
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value()) {
 if (u > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(u)));
}

template <class S>
 requires((UnsignedPrimitiveEnum<S> || UnsignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() < ::sus::mem::size_of<int8_t>())
__attribute__((pure)) static constexpr i8 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i8(static_cast<std::underlying_type_t<S>>(s));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<i8,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using D = std::underlying_type_t;
 using R = ::sus::result::Result<i8, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value<D>()) {
 if (static_cast<D>(u) > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i8(static_cast<int8_t>(u)));
}

static constexpr i8 from_product(
 ::sus::iter::Iterator<i8> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i8(int8_t{1});
 for (i8 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr i8 from_sum(::sus::iter::Iterator<i8> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i8(int8_t{0});
 for (i8 i : ::sus::move(it)) p += i;
 return p;
}

template <SignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<int8_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr int8_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const int8_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const int8_t* as_ptr() && noexcept = delete;

__attribute__((pure)) constexpr bool is_negative() const& noexcept {
 return primitive_value < 0;
}

__attribute__((pure)) constexpr bool is_positive() const& noexcept {
  return primitive_value > 0;
}

__attribute__((pure)) constexpr i8 signum() const& noexcept {
 if (primitive_value < 0)
 return int8_t{-1};
 else
 return int8_t{primitive_value != 0};
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i8 l, i8 r) noexcept = default;

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i8 l, Signed auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i8 l, SignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i8 l, i8 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i8 l, Signed auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i8 l, SignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline i8 operator-() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr inline i8 operator~() const& noexcept {
  return __private::into_signed(
      __private::unchecked_not(__private::into_unsigned(primitive_value)));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator+(
    i8 l, i8 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator+(
 i8 l, U r) noexcept {
 return l + i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator+(
 U l, i8 r) noexcept {
 return i8(l) + r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator+(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator+(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator-(
    i8 l, i8 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator-(
 i8 l, U r) noexcept {
 return l - i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator-(
 U l, i8 r) noexcept {
 return i8(l) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator-(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator-(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator*(
    i8 l, i8 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator*(
 i8 l, U r) noexcept {
 return l * i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator*(
 U l, i8 r) noexcept {
 return i8(l) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator*(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator*(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator/(
    i8 l, i8 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int8_t>(l.primitive_value / r.primitive_value);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator/(
 i8 l, U r) noexcept {
 return l / i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator/(
 U l, i8 r) noexcept {
 return i8(l) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator/(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator/(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator%(
    i8 l, i8 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int8_t>(l.primitive_value % r.primitive_value);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator%(
 i8 l, U r) noexcept {
 return l % i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator%(
 U l, i8 r) noexcept {
 return i8(l) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator%(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator%(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator&(
 i8 l, i8 r) noexcept {
 return static_cast<int8_t>(l.primitive_value & r.primitive_value);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator&(
 i8 l, U r) noexcept {
 return l & i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator&(
 U l, i8 r) noexcept {
 return i8(l) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator&(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator&(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator|(
 i8 l, i8 r) noexcept {
 return static_cast<int8_t>(l.primitive_value | r.primitive_value);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator|(
 i8 l, U r) noexcept {
 return l | i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator|(
 U l, i8 r) noexcept {
 return i8(l) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator|(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator|(U l, i8 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i8 operator^(
 i8 l, i8 r) noexcept {
 return static_cast<int8_t>(l.primitive_value ^ r.primitive_value);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator^(
 i8 l, U r) noexcept {
 return l ^ i8(r);
}

template <std::convertible_to<i8> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i8 operator^(
 U l, i8 r) noexcept {
 return i8(l) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator^(i8 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i8>)
friend constexpr inline i8 operator^(U l, i8 r) noexcept = delete;

constexpr inline void operator+=(i8 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(i8 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(i8 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(i8 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(i8 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(i8 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(i8 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(i8 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator>>=(u32 r) & noexcept {
  const auto out =
      __private::shr_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

__attribute__((pure)) constexpr inline i8 abs() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  if (primitive_value >= 0)
    return primitive_value;
  else
    return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr Option<i8> checked_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i8>(abs());
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(abs(), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i8 saturating_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MAX;
}

__attribute__((pure)) constexpr u8 unsigned_abs() const& noexcept {
  if (primitive_value >= 0) {
    return __private::into_unsigned(primitive_value);
  } else {
    const auto neg_plus_one =
        __private::unchecked_add(primitive_value, int8_t{1});
    const auto pos_minus_one =
        __private::into_unsigned(__private::unchecked_neg(neg_plus_one));
    return __private::unchecked_add(pos_minus_one, decltype(pos_minus_one){1});
  }
}

__attribute__((pure)) constexpr i8 wrapping_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MIN;
}

__attribute__((pure)) constexpr u8 abs_diff(i8 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return __private::sub_with_unsigned_positive_result(primitive_value,
                                                        other.primitive_value);
  } else {
    return __private::sub_with_unsigned_positive_result(other.primitive_value,
                                                        primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i8> checked_add(i8 rhs) const& noexcept {
 const auto out =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

__attribute__((pure)) constexpr Option<i8> checked_add_unsigned(
 u8 rhs) const& noexcept {
 const auto out = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add(i8 rhs) const& noexcept {
 const auto r =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add_unsigned(
 u8 rhs) const& noexcept {
 const auto r = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

__attribute__((pure)) constexpr i8 saturating_add(i8 rhs) const& noexcept {
  return __private::saturating_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 saturating_add_unsigned(
    u8 rhs) const& noexcept {
  const auto r = __private::add_with_overflow_unsigned(primitive_value,
                                                       rhs.primitive_value);
  if (!r.overflow) [[likely]]
    return r.value;
  else
    return MAX;
}

__attribute__((pure)) inline constexpr i8 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              i8 rhs) const& noexcept {
  return __private::unchecked_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 wrapping_add(i8 rhs) const& noexcept {
  return __private::wrapping_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 wrapping_add_unsigned(u8 rhs) const& noexcept {
  return __private::add_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i8> checked_div(i8 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i8>();
 else
 return Option<i8>(
 __private::unchecked_div(primitive_value, rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div(i8 rhs) const& noexcept {

__attribute__((pure)) constexpr i8 saturating_div(i8 rhs) const& noexcept {

return MAX;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i8 wrapping_div(i8 rhs) const& noexcept {

return MIN;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i8> checked_mul(i8 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_mul(i8 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i8 saturating_mul(i8 rhs) const& noexcept {
  return __private::saturating_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr inline i8 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                              i8 rhs) const& noexcept {
  return __private::unchecked_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 wrapping_mul(i8 rhs) const& noexcept {
  return __private::wrapping_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i8> checked_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i8>(__private::unchecked_neg(primitive_value));
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(__private::unchecked_neg(primitive_value), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i8 saturating_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MAX;
}

__attribute__((pure)) constexpr i8 wrapping_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MIN;
}

__attribute__((pure)) constexpr Option<i8> checked_rem(i8 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i8>();
 else
 return Option<i8>(
 static_cast<int8_t>(primitive_value % rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(int8_t{0}, true);
 } else {
 return Tuple(static_cast<int8_t>(primitive_value % rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr i8 wrapping_rem(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[likely]] {
 return int8_t{0};
 } else {
 return static_cast<int8_t>(primitive_value % rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr i8 div_euclid(i8 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i8> checked_div_euclid(i8 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i8>();
 } else {
 return Option<i8>(__private::div_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div_euclid(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::div_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i8 wrapping_div_euclid(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return MIN;
  } else {
    return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i8 rem_euclid(i8 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i8> checked_rem_euclid(i8 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i8>();
 } else {
 return Option<i8>(__private::rem_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem_euclid(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(int8_t{0}, true);
  } else {
    return Tuple(__private::rem_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i8 wrapping_rem_euclid(i8 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return int8_t{0};
  } else {
    return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i8> checked_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i8 wrapping_shl(u32 rhs) const& noexcept {
  return __private::shl_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i8> checked_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i8 wrapping_shr(u32 rhs) const& noexcept {
  return __private::shr_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i8> checked_sub(i8 rhs) const& {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

__attribute__((pure)) constexpr Option<i8> checked_sub_unsigned(u8 rhs) const& {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub(i8 rhs) const& noexcept {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub_unsigned(
 const u8& rhs) const& noexcept {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i8 saturating_sub(i8 rhs) const& {
  return __private::saturating_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 saturating_sub_unsigned(const u8& rhs) const& {
  const auto out = __private::sub_with_overflow_unsigned(primitive_value,
                                                         rhs.primitive_value);
  if (!out.overflow) [[likely]]
    return out.value;
  else
    return MIN;
}

__attribute__((pure)) inline constexpr i8 unchecked_sub(::sus::marker::UnsafeFnMarker,
 i8 rhs) const& {
 return static_cast<int8_t>(primitive_value - rhs.primitive_value);
}

constexpr i8 wrapping_sub(i8 rhs) const& {
  return __private::wrapping_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i8 wrapping_sub_unsigned(const u8& rhs) const& {
  return __private::sub_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr i8 reverse_bits() const& noexcept {
  return __private::into_signed(
      __private::reverse_bits(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr i8 rotate_left(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_left(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i8 rotate_right(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_right(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i8 swap_bytes() const& noexcept {
  return __private::into_signed(
      __private::swap_bytes(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr inline i8 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

__attribute__((pure)) constexpr Option<i8> checked_pow(u32 rhs) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, rhs.primitive_value);

if (!out.overflow) [[likely]]
 return Option<i8>(out.value);
 else
 return Option<i8>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i8, bool>>
__attribute__((pure)) constexpr Tuple overflowing_pow(u32 exp) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, exp.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i8 wrapping_pow(u32 exp) const& noexcept {
  return __private::wrapping_pow(primitive_value, exp.primitive_value);
}

__attribute__((pure)) constexpr Option<u32> checked_log2() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 uint32_t zeros = __private::leading_zeros_nonzero(
 ::sus::marker::unsafe_fn, __private::into_unsigned(primitive_value));
 return Option<u32>(u32(__private::num_bits<int8_t>()) - 1_u32 -
 u32(zeros));
 }
}

__attribute__((pure)) constexpr u32 log2() const& noexcept {

return checked_log2().unwrap();
}

__attribute__((pure)) constexpr u32 log10() const& noexcept {

return checked_log10().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log(i8 base) const& noexcept {
 if (primitive_value <= 0 || base.primitive_value <= 1) [[unlikely]] {
 return Option<u32>();
 } else {
 auto n = uint32_t{0};
 auto r = primitive_value;
 const auto b = base.primitive_value;
 while (r >= b) {
 r /= b;
 n += 1u;
 }
 return Option<u32>(n);
 }
}

__attribute__((pure)) constexpr u32 log(i8 base) const& noexcept {
  return checked_log(base).unwrap();
}

__attribute__((pure)) static constexpr i8 from_be(i8 x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) static constexpr i8 from_le(i8 x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr i8 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr i8 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int8_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int8_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int8_t>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static constexpr i8 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int8_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i8 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int8_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i8 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int8_t>()>&
 bytes) noexcept;

};

inline constexpr i8 i8::MIN = i8(i8::MIN_PRIMITIVE);
inline constexpr i8 i8::MAX = i8(i8::MAX_PRIMITIVE);
inline constexpr u32 i8::BITS = u32(__private::num_bits<int8_t>());

struct [[clang::trivial_abi]] i16 final {

int16_t primitive_value{0};

static constexpr auto MIN_PRIMITIVE = __private::min_value<int16_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<int16_t>();

static const i16 MIN;

static const i16 MAX;

static const u32 BITS;

constexpr inline i16() noexcept = default;

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16(S v) noexcept : primitive_value(v.primitive_value) {}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int16_t>())
explicit constexpr inline i16(P v) noexcept
 : primitive_value(static_cast<int16_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int16_t>())
constexpr inline i16(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int16_t>())
constexpr inline i16(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int16_t>())
constexpr inline i16(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int16_t>())
explicit constexpr inline i16(P v) noexcept
 : primitive_value(static_cast<int16_t>(v)) {}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16& operator=(S v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int16_t>())
constexpr inline i16& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 return i16(s);
}

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE) {
 if (s.primitive_value < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE) {
 if (s.primitive_value > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(s.primitive_value)));
}

template <Unsigned S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 return i16(s);
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < U::MAX_PRIMITIVE) {
 if (u.primitive_value > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(u.primitive_value)));
}

template <SignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 return i16(s);
}

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<S>()) {
 if (s < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<S>()) {
 if (s > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(s)));
}

template <class S>
 requires((SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() <= ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i16(static_cast<std::underlying_type_t<S>>(s));
}

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<D>()) {
 if (static_cast<D>(s) < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<D>()) {
 if (static_cast<D>(s) > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(s)));
}

template <UnsignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 return i16(s);
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value()) {
 if (u > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(u)));
}

template <class S>
 requires((UnsignedPrimitiveEnum<S> || UnsignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() < ::sus::mem::size_of<int16_t>())
__attribute__((pure)) static constexpr i16 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i16(static_cast<std::underlying_type_t<S>>(s));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<i16,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using D = std::underlying_type_t;
 using R = ::sus::result::Result<i16, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value<D>()) {
 if (static_cast<D>(u) > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i16(static_cast<int16_t>(u)));
}

static constexpr i16 from_product(
 ::sus::iter::Iterator<i16> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i16(int16_t{1});
 for (i16 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr i16 from_sum(::sus::iter::Iterator<i16> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i16(int16_t{0});
 for (i16 i : ::sus::move(it)) p += i;
 return p;
}

template <SignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<int16_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr int16_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const int16_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const int16_t* as_ptr() && noexcept = delete;

__attribute__((pure)) constexpr bool is_negative() const& noexcept {
 return primitive_value < 0;
}

__attribute__((pure)) constexpr bool is_positive() const& noexcept {
  return primitive_value > 0;
}

__attribute__((pure)) constexpr i16 signum() const& noexcept {
 if (primitive_value < 0)
 return int16_t{-1};
 else
 return int16_t{primitive_value != 0};
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i16 l, i16 r) noexcept = default;

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i16 l, Signed auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i16 l, SignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i16 l, i16 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i16 l, Signed auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i16 l, SignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline i16 operator-() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr inline i16 operator~() const& noexcept {
  return __private::into_signed(
      __private::unchecked_not(__private::into_unsigned(primitive_value)));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator+(
    i16 l, i16 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator+(
 i16 l, U r) noexcept {
 return l + i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator+(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator+(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator-(
    i16 l, i16 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator-(
 i16 l, U r) noexcept {
 return l - i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator-(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator-(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator*(
    i16 l, i16 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator*(
 i16 l, U r) noexcept {
 return l * i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator*(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator*(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator/(
    i16 l, i16 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int16_t>(l.primitive_value / r.primitive_value);
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator/(
 i16 l, U r) noexcept {
 return l / i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator/(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator/(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator%(
    i16 l, i16 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int16_t>(l.primitive_value % r.primitive_value);
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator%(
 i16 l, U r) noexcept {
 return l % i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator%(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator%(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator&(
 i16 l, i16 r) noexcept {
 return static_cast<int16_t>(l.primitive_value & r.primitive_value);
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator&(
 i16 l, U r) noexcept {
 return l & i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator&(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator&(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator|(
 i16 l, i16 r) noexcept {
 return static_cast<int16_t>(l.primitive_value | r.primitive_value);
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator|(
 i16 l, U r) noexcept {
 return l | i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator|(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator|(U l, i16 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i16 operator^(
 i16 l, i16 r) noexcept {
 return static_cast<int16_t>(l.primitive_value ^ r.primitive_value);
}

template <std::convertible_to<i16> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i16 operator^(
 i16 l, U r) noexcept {
 return l ^ i16(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator^(i16 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i16>)
friend constexpr inline i16 operator^(U l, i16 r) noexcept = delete;

constexpr inline void operator+=(i16 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(i16 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(i16 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(i16 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(i16 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(i16 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(i16 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(i16 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator>>=(u32 r) & noexcept {
  const auto out =
      __private::shr_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

__attribute__((pure)) constexpr inline i16 abs() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  if (primitive_value >= 0)
    return primitive_value;
  else
    return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr Option<i16> checked_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i16>(abs());
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(abs(), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i16 saturating_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MAX;
}

__attribute__((pure)) constexpr u16 unsigned_abs() const& noexcept {
  if (primitive_value >= 0) {
    return __private::into_unsigned(primitive_value);
  } else {
    const auto neg_plus_one =
        __private::unchecked_add(primitive_value, int16_t{1});
    const auto pos_minus_one =
        __private::into_unsigned(__private::unchecked_neg(neg_plus_one));
    return __private::unchecked_add(pos_minus_one, decltype(pos_minus_one){1});
  }
}

__attribute__((pure)) constexpr i16 wrapping_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MIN;
}

__attribute__((pure)) constexpr u16 abs_diff(i16 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return __private::sub_with_unsigned_positive_result(primitive_value,
                                                        other.primitive_value);
  } else {
    return __private::sub_with_unsigned_positive_result(other.primitive_value,
                                                        primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i16> checked_add(i16 rhs) const& noexcept {
 const auto out =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

__attribute__((pure)) constexpr Option<i16> checked_add_unsigned(
 u16 rhs) const& noexcept {
 const auto out = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add(i16 rhs) const& noexcept {
 const auto r =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add_unsigned(
 u16 rhs) const& noexcept {
 const auto r = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

__attribute__((pure)) constexpr i16 saturating_add(i16 rhs) const& noexcept {
  return __private::saturating_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 saturating_add_unsigned(
    u16 rhs) const& noexcept {
  const auto r = __private::add_with_overflow_unsigned(primitive_value,
                                                       rhs.primitive_value);
  if (!r.overflow) [[likely]]
    return r.value;
  else
    return MAX;
}

__attribute__((pure)) inline constexpr i16 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              i16 rhs) const& noexcept {
  return __private::unchecked_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 wrapping_add(i16 rhs) const& noexcept {
  return __private::wrapping_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 wrapping_add_unsigned(u16 rhs) const& noexcept {
  return __private::add_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i16> checked_div(i16 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i16>();
 else
 return Option<i16>(
 __private::unchecked_div(primitive_value, rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div(i16 rhs) const& noexcept {

__attribute__((pure)) constexpr i16 saturating_div(i16 rhs) const& noexcept {

return MAX;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i16 wrapping_div(i16 rhs) const& noexcept {

return MIN;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i16> checked_mul(i16 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_mul(i16 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i16 saturating_mul(i16 rhs) const& noexcept {
  return __private::saturating_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr inline i16 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                              i16 rhs) const& noexcept {
  return __private::unchecked_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 wrapping_mul(i16 rhs) const& noexcept {
  return __private::wrapping_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i16> checked_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i16>(__private::unchecked_neg(primitive_value));
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(__private::unchecked_neg(primitive_value), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i16 saturating_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MAX;
}

__attribute__((pure)) constexpr i16 wrapping_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MIN;
}

__attribute__((pure)) constexpr Option<i16> checked_rem(i16 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i16>();
 else
 return Option<i16>(
 static_cast<int16_t>(primitive_value % rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(int16_t{0}, true);
 } else {
 return Tuple(static_cast<int16_t>(primitive_value % rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr i16 wrapping_rem(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[likely]] {
 return int16_t{0};
 } else {
 return static_cast<int16_t>(primitive_value % rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr i16 div_euclid(i16 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i16> checked_div_euclid(i16 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i16>();
 } else {
 return Option<i16>(__private::div_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div_euclid(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::div_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i16 wrapping_div_euclid(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return MIN;
  } else {
    return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i16 rem_euclid(i16 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i16> checked_rem_euclid(i16 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i16>();
 } else {
 return Option<i16>(__private::rem_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem_euclid(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(int16_t{0}, true);
  } else {
    return Tuple(__private::rem_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i16 wrapping_rem_euclid(i16 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return int16_t{0};
  } else {
    return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i16> checked_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i16 wrapping_shl(u32 rhs) const& noexcept {
  return __private::shl_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i16> checked_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i16 wrapping_shr(u32 rhs) const& noexcept {
  return __private::shr_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i16> checked_sub(i16 rhs) const& {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

__attribute__((pure)) constexpr Option<i16> checked_sub_unsigned(u16 rhs) const& {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub(i16 rhs) const& noexcept {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub_unsigned(
 const u16& rhs) const& noexcept {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i16 saturating_sub(i16 rhs) const& {
  return __private::saturating_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 saturating_sub_unsigned(const u16& rhs) const& {
  const auto out = __private::sub_with_overflow_unsigned(primitive_value,
                                                         rhs.primitive_value);
  if (!out.overflow) [[likely]]
    return out.value;
  else
    return MIN;
}

__attribute__((pure)) inline constexpr i16 unchecked_sub(::sus::marker::UnsafeFnMarker,
 i16 rhs) const& {
 return static_cast<int16_t>(primitive_value - rhs.primitive_value);
}

constexpr i16 wrapping_sub(i16 rhs) const& {
  return __private::wrapping_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i16 wrapping_sub_unsigned(const u16& rhs) const& {
  return __private::sub_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr i16 reverse_bits() const& noexcept {
  return __private::into_signed(
      __private::reverse_bits(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr i16 rotate_left(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_left(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i16 rotate_right(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_right(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i16 swap_bytes() const& noexcept {
  return __private::into_signed(
      __private::swap_bytes(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr inline i16 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

__attribute__((pure)) constexpr Option<i16> checked_pow(u32 rhs) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, rhs.primitive_value);

if (!out.overflow) [[likely]]
 return Option<i16>(out.value);
 else
 return Option<i16>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i16, bool>>
__attribute__((pure)) constexpr Tuple overflowing_pow(u32 exp) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, exp.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i16 wrapping_pow(u32 exp) const& noexcept {
  return __private::wrapping_pow(primitive_value, exp.primitive_value);
}

__attribute__((pure)) constexpr Option<u32> checked_log2() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 uint32_t zeros = __private::leading_zeros_nonzero(
 ::sus::marker::unsafe_fn, __private::into_unsigned(primitive_value));
 return Option<u32>(u32(__private::num_bits<int16_t>()) - 1_u32 -
 u32(zeros));
 }
}

__attribute__((pure)) constexpr u32 log2() const& noexcept {

return checked_log2().unwrap();
}

__attribute__((pure)) constexpr u32 log10() const& noexcept {

return checked_log10().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log(i16 base) const& noexcept {
 if (primitive_value <= 0 || base.primitive_value <= 1) [[unlikely]] {
 return Option<u32>();
 } else {
 auto n = uint32_t{0};
 auto r = primitive_value;
 const auto b = base.primitive_value;
 while (r >= b) {
 r /= b;
 n += 1u;
 }
 return Option<u32>(n);
 }
}

__attribute__((pure)) constexpr u32 log(i16 base) const& noexcept {
  return checked_log(base).unwrap();
}

__attribute__((pure)) static constexpr i16 from_be(i16 x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) static constexpr i16 from_le(i16 x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr i16 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr i16 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int16_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int16_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int16_t>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static constexpr i16 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int16_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i16 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int16_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i16 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int16_t>()>&
 bytes) noexcept;

};

inline constexpr i16 i16::MIN = i16(i16::MIN_PRIMITIVE);
inline constexpr i16 i16::MAX = i16(i16::MAX_PRIMITIVE);
inline constexpr u32 i16::BITS = u32(__private::num_bits<int16_t>());

struct [[clang::trivial_abi]] i64 final {

int64_t primitive_value{0};

static constexpr auto MIN_PRIMITIVE = __private::min_value<int64_t>();

static constexpr auto MAX_PRIMITIVE = __private::max_value<int64_t>();

static const i64 MIN;

static const i64 MAX;

static const u32 BITS;

constexpr inline i64() noexcept = default;

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64(S v) noexcept : primitive_value(v.primitive_value) {}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int64_t>())
explicit constexpr inline i64(P v) noexcept
 : primitive_value(static_cast<int64_t>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int64_t>())
constexpr inline i64(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int64_t>())
constexpr inline i64(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int64_t>())
constexpr inline i64(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of<int64_t>())
explicit constexpr inline i64(P v) noexcept
 : primitive_value(static_cast<int64_t>(v)) {}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64& operator=(S v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<int64_t>())
constexpr inline i64& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 return i64(s);
}

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE) {
 if (s.primitive_value < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE) {
 if (s.primitive_value > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(s.primitive_value)));
}

template <Unsigned S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 return i64(s);
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < U::MAX_PRIMITIVE) {
 if (u.primitive_value > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(u.primitive_value)));
}

template <SignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 return i64(s);
}

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<S>()) {
 if (s < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<S>()) {
 if (s > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(s)));
}

template <class S>
 requires((SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() <= ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i64(static_cast<std::underlying_type_t<S>>(s));
}

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<D>()) {
 if (static_cast<D>(s) < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<D>()) {
 if (static_cast<D>(s) > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(s)));
}

template <UnsignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 return i64(s);
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value()) {
 if (u > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(u)));
}

template <class S>
 requires((UnsignedPrimitiveEnum<S> || UnsignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() < ::sus::mem::size_of<int64_t>())
__attribute__((pure)) static constexpr i64 from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return i64(static_cast<std::underlying_type_t<S>>(s));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<i64,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using D = std::underlying_type_t;
 using R = ::sus::result::Result<i64, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value<D>()) {
 if (static_cast<D>(u) > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(i64(static_cast<int64_t>(u)));
}

static constexpr i64 from_product(
 ::sus::iter::Iterator<i64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i64(int64_t{1});
 for (i64 i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr i64 from_sum(::sus::iter::Iterator<i64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = i64(int64_t{0});
 for (i64 i : ::sus::move(it)) p += i;
 return p;
}

template <SignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<int64_t>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr int64_t* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const int64_t* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const int64_t* as_ptr() && noexcept = delete;

__attribute__((pure)) constexpr bool is_negative() const& noexcept {
 return primitive_value < 0;
}

__attribute__((pure)) constexpr bool is_positive() const& noexcept {
  return primitive_value > 0;
}

__attribute__((pure)) constexpr i64 signum() const& noexcept {
 if (primitive_value < 0)
 return int64_t{-1};
 else
 return int64_t{primitive_value != 0};
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i64 l, i64 r) noexcept = default;

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i64 l, Signed auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    i64 l, SignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i64 l, i64 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i64 l, Signed auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 i64 l, SignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline i64 operator-() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr inline i64 operator~() const& noexcept {
  return __private::into_signed(
      __private::unchecked_not(__private::into_unsigned(primitive_value)));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator+(
    i64 l, i64 r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator+(
 i64 l, U r) noexcept {
 return l + i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator+(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator+(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator-(
    i64 l, i64 r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator-(
 i64 l, U r) noexcept {
 return l - i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator-(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator-(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator*(
    i64 l, i64 r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator*(
 i64 l, U r) noexcept {
 return l * i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator*(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator*(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator/(
    i64 l, i64 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int64_t>(l.primitive_value / r.primitive_value);
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator/(
 i64 l, U r) noexcept {
 return l / i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator/(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator/(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator%(
    i64 l, i64 r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast<int64_t>(l.primitive_value % r.primitive_value);
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator%(
 i64 l, U r) noexcept {
 return l % i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator%(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator%(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator&(
 i64 l, i64 r) noexcept {
 return static_cast<int64_t>(l.primitive_value & r.primitive_value);
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator&(
 i64 l, U r) noexcept {
 return l & i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator&(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator&(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator|(
 i64 l, i64 r) noexcept {
 return static_cast<int64_t>(l.primitive_value | r.primitive_value);
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator|(
 i64 l, U r) noexcept {
 return l | i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator|(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator|(U l, i64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline i64 operator^(
 i64 l, i64 r) noexcept {
 return static_cast<int64_t>(l.primitive_value ^ r.primitive_value);
}

template <std::convertible_to<i64> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline i64 operator^(
 i64 l, U r) noexcept {
 return l ^ i64(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator^(i64 l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, i64>)
friend constexpr inline i64 operator^(U l, i64 r) noexcept = delete;

constexpr inline void operator+=(i64 r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(i64 r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(i64 r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(i64 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(i64 r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(i64 r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(i64 r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(i64 r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator>>=(u32 r) & noexcept {
  const auto out =
      __private::shr_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

__attribute__((pure)) constexpr inline i64 abs() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  if (primitive_value >= 0)
    return primitive_value;
  else
    return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr Option<i64> checked_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i64>(abs());
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(abs(), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i64 saturating_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MAX;
}

__attribute__((pure)) constexpr u64 unsigned_abs() const& noexcept {
  if (primitive_value >= 0) {
    return __private::into_unsigned(primitive_value);
  } else {
    const auto neg_plus_one =
        __private::unchecked_add(primitive_value, int64_t{1});
    const auto pos_minus_one =
        __private::into_unsigned(__private::unchecked_neg(neg_plus_one));
    return __private::unchecked_add(pos_minus_one, decltype(pos_minus_one){1});
  }
}

__attribute__((pure)) constexpr i64 wrapping_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MIN;
}

__attribute__((pure)) constexpr u64 abs_diff(i64 other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return __private::sub_with_unsigned_positive_result(primitive_value,
                                                        other.primitive_value);
  } else {
    return __private::sub_with_unsigned_positive_result(other.primitive_value,
                                                        primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i64> checked_add(i64 rhs) const& noexcept {
 const auto out =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

__attribute__((pure)) constexpr Option<i64> checked_add_unsigned(
 u64 rhs) const& noexcept {
 const auto out = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add(i64 rhs) const& noexcept {
 const auto r =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add_unsigned(
 u64 rhs) const& noexcept {
 const auto r = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

__attribute__((pure)) constexpr i64 saturating_add(i64 rhs) const& noexcept {
  return __private::saturating_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 saturating_add_unsigned(
    u64 rhs) const& noexcept {
  const auto r = __private::add_with_overflow_unsigned(primitive_value,
                                                       rhs.primitive_value);
  if (!r.overflow) [[likely]]
    return r.value;
  else
    return MAX;
}

__attribute__((pure)) inline constexpr i64 unchecked_add(::sus::marker::UnsafeFnMarker,
                                              i64 rhs) const& noexcept {
  return __private::unchecked_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 wrapping_add(i64 rhs) const& noexcept {
  return __private::wrapping_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 wrapping_add_unsigned(u64 rhs) const& noexcept {
  return __private::add_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i64> checked_div(i64 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i64>();
 else
 return Option<i64>(
 __private::unchecked_div(primitive_value, rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div(i64 rhs) const& noexcept {

__attribute__((pure)) constexpr i64 saturating_div(i64 rhs) const& noexcept {

return MAX;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i64 wrapping_div(i64 rhs) const& noexcept {

return MIN;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i64> checked_mul(i64 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_mul(i64 rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i64 saturating_mul(i64 rhs) const& noexcept {
  return __private::saturating_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr inline i64 unchecked_mul(::sus::marker::UnsafeFnMarker,
                                              i64 rhs) const& noexcept {
  return __private::unchecked_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 wrapping_mul(i64 rhs) const& noexcept {
  return __private::wrapping_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<i64> checked_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<i64>(__private::unchecked_neg(primitive_value));
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(__private::unchecked_neg(primitive_value), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr i64 saturating_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MAX;
}

__attribute__((pure)) constexpr i64 wrapping_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MIN;
}

__attribute__((pure)) constexpr Option<i64> checked_rem(i64 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<i64>();
 else
 return Option<i64>(
 static_cast<int64_t>(primitive_value % rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(int64_t{0}, true);
 } else {
 return Tuple(static_cast<int64_t>(primitive_value % rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr i64 wrapping_rem(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[likely]] {
 return int64_t{0};
 } else {
 return static_cast<int64_t>(primitive_value % rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr i64 div_euclid(i64 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i64> checked_div_euclid(i64 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i64>();
 } else {
 return Option<i64>(__private::div_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div_euclid(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::div_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i64 wrapping_div_euclid(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return MIN;
  } else {
    return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr i64 rem_euclid(i64 rhs) const& noexcept {

__attribute__((pure)) constexpr Option<i64> checked_rem_euclid(i64 rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<i64>();
 } else {
 return Option<i64>(__private::rem_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem_euclid(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(int64_t{0}, true);
  } else {
    return Tuple(__private::rem_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr i64 wrapping_rem_euclid(i64 rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return int64_t{0};
  } else {
    return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<i64> checked_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i64 wrapping_shl(u32 rhs) const& noexcept {
  return __private::shl_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i64> checked_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i64 wrapping_shr(u32 rhs) const& noexcept {
  return __private::shr_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<i64> checked_sub(i64 rhs) const& {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

__attribute__((pure)) constexpr Option<i64> checked_sub_unsigned(u64 rhs) const& {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub(i64 rhs) const& noexcept {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub_unsigned(
 const u64& rhs) const& noexcept {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i64 saturating_sub(i64 rhs) const& {
  return __private::saturating_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 saturating_sub_unsigned(const u64& rhs) const& {
  const auto out = __private::sub_with_overflow_unsigned(primitive_value,
                                                         rhs.primitive_value);
  if (!out.overflow) [[likely]]
    return out.value;
  else
    return MIN;
}

__attribute__((pure)) inline constexpr i64 unchecked_sub(::sus::marker::UnsafeFnMarker,
 i64 rhs) const& {
 return static_cast<int64_t>(primitive_value - rhs.primitive_value);
}

constexpr i64 wrapping_sub(i64 rhs) const& {
  return __private::wrapping_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr i64 wrapping_sub_unsigned(const u64& rhs) const& {
  return __private::sub_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr i64 reverse_bits() const& noexcept {
  return __private::into_signed(
      __private::reverse_bits(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr i64 rotate_left(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_left(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i64 rotate_right(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_right(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr i64 swap_bytes() const& noexcept {
  return __private::into_signed(
      __private::swap_bytes(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr inline i64 pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

__attribute__((pure)) constexpr Option<i64> checked_pow(u32 rhs) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, rhs.primitive_value);

if (!out.overflow) [[likely]]
 return Option<i64>(out.value);
 else
 return Option<i64>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<i64, bool>>
__attribute__((pure)) constexpr Tuple overflowing_pow(u32 exp) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, exp.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr i64 wrapping_pow(u32 exp) const& noexcept {
  return __private::wrapping_pow(primitive_value, exp.primitive_value);
}

__attribute__((pure)) constexpr Option<u32> checked_log2() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 uint32_t zeros = __private::leading_zeros_nonzero(
 ::sus::marker::unsafe_fn, __private::into_unsigned(primitive_value));
 return Option<u32>(u32(__private::num_bits<int64_t>()) - 1_u32 -
 u32(zeros));
 }
}

__attribute__((pure)) constexpr u32 log2() const& noexcept {

return checked_log2().unwrap();
}

__attribute__((pure)) constexpr u32 log10() const& noexcept {

return checked_log10().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log(i64 base) const& noexcept {
 if (primitive_value <= 0 || base.primitive_value <= 1) [[unlikely]] {
 return Option<u32>();
 } else {
 auto n = uint32_t{0};
 auto r = primitive_value;
 const auto b = base.primitive_value;
 while (r >= b) {
 r /= b;
 n += 1u;
 }
 return Option<u32>(n);
 }
}

__attribute__((pure)) constexpr u32 log(i64 base) const& noexcept {
  return checked_log(base).unwrap();
}

__attribute__((pure)) static constexpr i64 from_be(i64 x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) static constexpr i64 from_le(i64 x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr i64 to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr i64 to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int64_t>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int64_t>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<int64_t>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static constexpr i64 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int64_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i64 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int64_t>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr i64 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<int64_t>()>&
 bytes) noexcept;

};

inline constexpr i64 i64::MIN = i64(i64::MIN_PRIMITIVE);
inline constexpr i64 i64::MAX = i64(i64::MAX_PRIMITIVE);
inline constexpr u32 i64::BITS = u32(__private::num_bits<int64_t>());

struct [[clang::trivial_abi]] isize final {

::sus::num::__private::addr_type<>::signed_type primitive_value{0};

static constexpr auto MIN_PRIMITIVE = __private::min_value< ::sus::num::__private::addr_type<>::signed_type>();

static constexpr auto MAX_PRIMITIVE = __private::max_value< ::sus::num::__private::addr_type<>::signed_type>();

static const isize MIN;

static const isize MAX;

static const u32 BITS;

constexpr inline isize() noexcept = default;

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(S v) noexcept : primitive_value(v.primitive_value) {}

template <SignedPrimitiveInteger P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnum P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(P v) noexcept : primitive_value(v) {}

template <SignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
explicit constexpr inline isize(P v) noexcept
 : primitive_value(static_cast< ::sus::num::__private::addr_type<>::signed_type>(v)) {}

template <Unsigned U>
 requires(::sus::mem::size_of() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(U v) noexcept : primitive_value(v.primitive_value) {}

template <UnsignedPrimitiveInteger P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnum P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize(P v) noexcept : primitive_value(v) {}

template <UnsignedPrimitiveEnumClass P>
 requires(::sus::mem::size_of() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
explicit constexpr inline isize(P v) noexcept
 : primitive_value(static_cast< ::sus::num::__private::addr_type<>::signed_type>(v)) {}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
constexpr inline isize& operator=(S v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <Signed S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 return isize(s);
}

template <Signed S>
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > S::MIN_PRIMITIVE) {
 if (s.primitive_value < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < S::MAX_PRIMITIVE) {
 if (s.primitive_value > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(s.primitive_value)));
}

template <Unsigned S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 return isize(s);
}

template <Unsigned U>
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < U::MAX_PRIMITIVE) {
 if (u.primitive_value > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(u.primitive_value)));
}

template <SignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 return isize(s);
}

template <SignedPrimitiveInteger S>
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<S>()) {
 if (s < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<S>()) {
 if (s > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(s)));
}

template <class S>
 requires((SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() <= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return isize(static_cast<std::underlying_type_t<S>>(s));
}

template <class S>
 requires(SignedPrimitiveEnum<S> || SignedPrimitiveEnumClass<S>)
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 if constexpr (MIN_PRIMITIVE > __private::min_value<D>()) {
 if (static_cast<D>(s) < MIN_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 if constexpr (MAX_PRIMITIVE < __private::max_value<D>()) {
 if (static_cast<D>(s) > MAX_PRIMITIVE) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(s)));
}

template <UnsignedPrimitiveInteger S>
 requires(::sus::mem::size_of<S>() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 return isize(s);
}

template <UnsignedPrimitiveInteger U>
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value()) {
 if (u > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(u)));
}

template <class S>
 requires((UnsignedPrimitiveEnum<S> || UnsignedPrimitiveEnumClass<S>) &&
 ::sus::mem::size_of<S>() < ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) static constexpr isize from(S s) noexcept {
 using D = std::underlying_type_t<S>;
 return isize(static_cast<std::underlying_type_t<S>>(s));
}

template <class U>
 requires(UnsignedPrimitiveEnum || UnsignedPrimitiveEnumClass)
__attribute__((pure)) static constexpr ::sus::result::Result<isize,
 ::sus::num::TryFromIntError>
try_from(U u) noexcept {
 using D = std::underlying_type_t;
 using R = ::sus::result::Result<isize, ::sus::num::TryFromIntError>;
 constexpr auto umax = __private::into_unsigned(MAX_PRIMITIVE);
 if constexpr (umax < __private::max_value<D>()) {
 if (static_cast<D>(u) > umax) {
 return R::with_err(::sus::num::TryFromIntError::with_out_of_bounds());
 }
 }
 return R(isize(static_cast< ::sus::num::__private::addr_type<>::signed_type>(u)));
}

static constexpr isize from_product(
 ::sus::iter::Iterator<isize> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = isize(::sus::num::__private::addr_type<>::signed_type{1});
 for (isize i : ::sus::move(it)) p *= i;
 return p;
}

static constexpr isize from_sum(::sus::iter::Iterator<isize> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = isize(::sus::num::__private::addr_type<>::signed_type{0});
 for (isize i : ::sus::move(it)) p += i;
 return p;
}

template <SignedPrimitiveInteger U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr ::sus::num::__private::addr_type<>::signed_type* as_mut_ptr() & noexcept {
 return &primitive_value;
}

__attribute__((pure)) constexpr const ::sus::num::__private::addr_type<>::signed_type* as_ptr() const& noexcept {
 return &primitive_value;
}
__attribute__((pure)) constexpr const ::sus::num::__private::addr_type<>::signed_type* as_ptr() && noexcept = delete;

__attribute__((pure)) constexpr bool is_negative() const& noexcept {
 return primitive_value < 0;
}

__attribute__((pure)) constexpr bool is_positive() const& noexcept {
  return primitive_value > 0;
}

__attribute__((pure)) constexpr isize signum() const& noexcept {
 if (primitive_value < 0)
 return ::sus::num::__private::addr_type<>::signed_type{-1};
 else
 return ::sus::num::__private::addr_type<>::signed_type{primitive_value != 0};
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    isize l, isize r) noexcept = default;

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    isize l, Signed auto r) noexcept {
  return l.primitive_value == r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline bool operator==(
    isize l, SignedPrimitiveInteger auto r) noexcept {
  return l.primitive_value == r;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 isize l, isize r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 isize l, Signed auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline std::strong_ordering operator<=>(
 isize l, SignedPrimitiveInteger auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr inline isize operator-() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr inline isize operator~() const& noexcept {
  return __private::into_signed(
      __private::unchecked_not(__private::into_unsigned(primitive_value)));
}

[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator+(
    isize l, isize r) noexcept {
  const auto out =
      __private::add_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator+(
 isize l, U r) noexcept {
 return l + isize(r);
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator+(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator+(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator-(
    isize l, isize r) noexcept {
  const auto out =
      __private::sub_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator-(
 isize l, U r) noexcept {
 return l - isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator-(
 U l, isize r) noexcept {
 return isize(l) - r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator-(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator-(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator*(
    isize l, isize r) noexcept {
  const auto out =
      __private::mul_with_overflow(l.primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator*(
 isize l, U r) noexcept {
 return l * isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator*(
 U l, isize r) noexcept {
 return isize(l) * r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator*(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator*(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator/(
    isize l, isize r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(l.primitive_value / r.primitive_value);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator/(
 isize l, U r) noexcept {
 return l / isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator/(
 U l, isize r) noexcept {
 return isize(l) / r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator/(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator/(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator%(
    isize l, isize r) noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(l.primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(l.primitive_value % r.primitive_value);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator%(
 isize l, U r) noexcept {
 return l % isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator%(
 U l, isize r) noexcept {
 return isize(l) % r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator%(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator%(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator&(
 isize l, isize r) noexcept {
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(l.primitive_value & r.primitive_value);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator&(
 isize l, U r) noexcept {
 return l & isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator&(
 U l, isize r) noexcept {
 return isize(l) & r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator&(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator&(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator|(
 isize l, isize r) noexcept {
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(l.primitive_value | r.primitive_value);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator|(
 isize l, U r) noexcept {
 return l | isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator|(
 U l, isize r) noexcept {
 return isize(l) | r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator|(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator|(U l, isize r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline isize operator^(
 isize l, isize r) noexcept {
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(l.primitive_value ^ r.primitive_value);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator^(
 isize l, U r) noexcept {
 return l ^ isize(r);
}

template <std::convertible_to<isize> U>
 requires(PrimitiveInteger || PrimitiveEnum)
[[nodiscard]] __attribute__((const)) friend constexpr inline isize operator^(
 U l, isize r) noexcept {
 return isize(l) ^ r;
}

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator^(isize l, U r) noexcept = delete;

template <class U>
 requires((PrimitiveInteger || PrimitiveEnum) &&
 !std::convertible_to<U, isize>)
friend constexpr inline isize operator^(U l, isize r) noexcept = delete;

constexpr inline void operator+=(isize r) & noexcept {
  const auto out =
      __private::add_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator-=(isize r) & noexcept {
  const auto out =
      __private::sub_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator*=(isize r) & noexcept {
  const auto out =
      __private::mul_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator/=(isize r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(isize r) & noexcept {

::sus::check(r.primitive_value != 0);

::sus::check(primitive_value != MIN_PRIMITIVE || r.primitive_value != -1);
  primitive_value %= r.primitive_value;
}

constexpr inline void operator&=(isize r) & noexcept {
  primitive_value &= r.primitive_value;
}

constexpr inline void operator|=(isize r) & noexcept {
  primitive_value |= r.primitive_value;
}

constexpr inline void operator^=(isize r) & noexcept {
  primitive_value ^= r.primitive_value;
}

constexpr inline void operator<<=(u32 r) & noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

constexpr inline void operator>>=(u32 r) & noexcept {
  const auto out =
      __private::shr_with_overflow(primitive_value, r.primitive_value);

::sus::check(!out.overflow);
  primitive_value = out.value;
}

__attribute__((pure)) constexpr inline isize abs() const& noexcept {

::sus::check(primitive_value != MIN_PRIMITIVE);
  if (primitive_value >= 0)
    return primitive_value;
  else
    return __private::unchecked_neg(primitive_value);
}

__attribute__((pure)) constexpr Option<isize> checked_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<isize>(abs());
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_abs() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(abs(), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr isize saturating_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MAX;
}

__attribute__((pure)) constexpr usize unsigned_abs() const& noexcept {
 if (primitive_value >= 0) {
 return __private::into_unsigned(primitive_value);
 } else {
 const auto neg_plus_one =
 __private::unchecked_add(primitive_value, ::sus::num::__private::addr_type<>::signed_type{1});
 const auto pos_minus_one =
 __private::into_unsigned(__private::unchecked_neg(neg_plus_one));
 return __private::unchecked_add(pos_minus_one, decltype(pos_minus_one){1});
 }
}

__attribute__((pure)) constexpr isize wrapping_abs() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return abs();
  else
    return MIN;
}

__attribute__((pure)) constexpr usize abs_diff(isize other) const& noexcept {
  if (primitive_value >= other.primitive_value) {
    return __private::sub_with_unsigned_positive_result(primitive_value,
                                                        other.primitive_value);
  } else {
    return __private::sub_with_unsigned_positive_result(other.primitive_value,
                                                        primitive_value);
  }
}

__attribute__((pure)) constexpr Option<isize> checked_add(isize rhs) const& noexcept {
 const auto out =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

__attribute__((pure)) constexpr Option<isize> checked_add_unsigned(
 usize rhs) const& noexcept {
 const auto out = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add(isize rhs) const& noexcept {
 const auto r =
 __private::add_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_add_unsigned(
 usize rhs) const& noexcept {
 const auto r = __private::add_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(r.value, r.overflow);
}

__attribute__((pure)) constexpr isize saturating_add(isize rhs) const& noexcept {
  return __private::saturating_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize saturating_add_unsigned(
    usize rhs) const& noexcept {
  const auto r = __private::add_with_overflow_unsigned(primitive_value,
                                                       rhs.primitive_value);
  if (!r.overflow) [[likely]]
    return r.value;
  else
    return MAX;
}

__attribute__((pure)) inline constexpr isize unchecked_add(::sus::marker::UnsafeFnMarker,
                                              isize rhs) const& noexcept {
  return __private::unchecked_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize wrapping_add(isize rhs) const& noexcept {
  return __private::wrapping_add(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize wrapping_add_unsigned(usize rhs) const& noexcept {
  return __private::add_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<isize> checked_div(isize rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<isize>();
 else
 return Option<isize>(
 __private::unchecked_div(primitive_value, rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div(isize rhs) const& noexcept {

__attribute__((pure)) constexpr isize saturating_div(isize rhs) const& noexcept {

return MAX;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr isize wrapping_div(isize rhs) const& noexcept {

return MIN;
  } else {
    return __private::unchecked_div(primitive_value, rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr Option<isize> checked_mul(isize rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_mul(isize rhs) const& noexcept {
 const auto out =
 __private::mul_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr isize saturating_mul(isize rhs) const& noexcept {
  return __private::saturating_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr inline isize unchecked_mul(::sus::marker::UnsafeFnMarker,
                                              isize rhs) const& noexcept {
  return __private::unchecked_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize wrapping_mul(isize rhs) const& noexcept {
  return __private::wrapping_mul(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr Option<isize> checked_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Option<isize>(__private::unchecked_neg(primitive_value));
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_neg() const& noexcept {
 if (primitive_value != MIN_PRIMITIVE) [[likely]]
 return Tuple(__private::unchecked_neg(primitive_value), false);
 else
 return Tuple(MIN, true);
}

__attribute__((pure)) constexpr isize saturating_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MAX;
}

__attribute__((pure)) constexpr isize wrapping_neg() const& noexcept {
  if (primitive_value != MIN_PRIMITIVE) [[likely]]
    return __private::unchecked_neg(primitive_value);
  else
    return MIN;
}

__attribute__((pure)) constexpr Option<isize> checked_rem(isize rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]]
 return Option<isize>();
 else
 return Option<isize>(
 static_cast< ::sus::num::__private::addr_type<>::signed_type>(primitive_value % rhs.primitive_value));
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(::sus::num::__private::addr_type<>::signed_type{0}, true);
 } else {
 return Tuple(static_cast< ::sus::num::__private::addr_type<>::signed_type>(primitive_value % rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr isize wrapping_rem(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[likely]] {
 return ::sus::num::__private::addr_type<>::signed_type{0};
 } else {
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(primitive_value % rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr isize div_euclid(isize rhs) const& noexcept {

__attribute__((pure)) constexpr Option<isize> checked_div_euclid(isize rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<isize>();
 } else {
 return Option<isize>(__private::div_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_div_euclid(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return Tuple(MIN, true);
  } else {
    return Tuple(__private::div_euclid(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value),
                 false);
  }
}

__attribute__((pure)) constexpr isize wrapping_div_euclid(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
  if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
                                       primitive_value, rhs.primitive_value))
      [[unlikely]] {
    return MIN;
  } else {
    return __private::div_euclid(::sus::marker::unsafe_fn, primitive_value,
                                 rhs.primitive_value);
  }
}

__attribute__((pure)) constexpr isize rem_euclid(isize rhs) const& noexcept {

__attribute__((pure)) constexpr Option<isize> checked_rem_euclid(isize rhs) const& noexcept {
 if (__private::div_overflows(primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Option<isize>();
 } else {
 return Option<isize>(__private::rem_euclid(
 ::sus::marker::unsafe_fn, primitive_value, rhs.primitive_value));
 }
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_rem_euclid(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return Tuple(::sus::num::__private::addr_type<>::signed_type{0}, true);
 } else {
 return Tuple(__private::rem_euclid(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value),
 false);
 }
}

__attribute__((pure)) constexpr isize wrapping_rem_euclid(isize rhs) const& noexcept {

::sus::check(rhs.primitive_value != 0);
 if (__private::div_overflows_nonzero(::sus::marker::unsafe_fn,
 primitive_value, rhs.primitive_value))
 [[unlikely]] {
 return ::sus::num::__private::addr_type<>::signed_type{0};
 } else {
 return __private::rem_euclid(::sus::marker::unsafe_fn, primitive_value,
 rhs.primitive_value);
 }
}

__attribute__((pure)) constexpr Option<isize> checked_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shl(u32 rhs) const& noexcept {
 const auto out =
 __private::shl_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr isize wrapping_shl(u32 rhs) const& noexcept {
  return __private::shl_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<isize> checked_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_shr(u32 rhs) const& noexcept {
 const auto out =
 __private::shr_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr isize wrapping_shr(u32 rhs) const& noexcept {
  return __private::shr_with_overflow(primitive_value, rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr Option<isize> checked_sub(isize rhs) const& {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

__attribute__((pure)) constexpr Option<isize> checked_sub_unsigned(usize rhs) const& {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub(isize rhs) const& noexcept {
 const auto out =
 __private::sub_with_overflow(primitive_value, rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_sub_unsigned(
 const usize& rhs) const& noexcept {
 const auto out = __private::sub_with_overflow_unsigned(primitive_value,
 rhs.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr isize saturating_sub(isize rhs) const& {
  return __private::saturating_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize saturating_sub_unsigned(const usize& rhs) const& {
  const auto out = __private::sub_with_overflow_unsigned(primitive_value,
                                                         rhs.primitive_value);
  if (!out.overflow) [[likely]]
    return out.value;
  else
    return MIN;
}

__attribute__((pure)) inline constexpr isize unchecked_sub(::sus::marker::UnsafeFnMarker,
 isize rhs) const& {
 return static_cast< ::sus::num::__private::addr_type<>::signed_type>(primitive_value - rhs.primitive_value);
}

constexpr isize wrapping_sub(isize rhs) const& {
  return __private::wrapping_sub(primitive_value, rhs.primitive_value);
}

__attribute__((pure)) constexpr isize wrapping_sub_unsigned(const usize& rhs) const& {
  return __private::sub_with_overflow_unsigned(primitive_value,
                                               rhs.primitive_value)
      .value;
}

__attribute__((pure)) constexpr u32 count_ones() const& noexcept {
  return __private::count_ones(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 count_zeros() const& noexcept {
  return (~(*this)).count_ones();
}

__attribute__((pure)) constexpr u32 leading_ones() const& noexcept {
  return (~(*this)).leading_zeros();
}

__attribute__((pure)) constexpr u32 leading_zeros() const& noexcept {
  return __private::leading_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr u32 trailing_ones() const& noexcept {
  return (~(*this)).trailing_zeros();
}

__attribute__((pure)) constexpr u32 trailing_zeros() const& noexcept {
  return __private::trailing_zeros(__private::into_unsigned(primitive_value));
}

__attribute__((pure)) constexpr isize reverse_bits() const& noexcept {
  return __private::into_signed(
      __private::reverse_bits(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr isize rotate_left(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_left(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr isize rotate_right(u32 n) const& noexcept {
  return __private::into_signed(__private::rotate_right(
      __private::into_unsigned(primitive_value), n.primitive_value));
}

__attribute__((pure)) constexpr isize swap_bytes() const& noexcept {
  return __private::into_signed(
      __private::swap_bytes(__private::into_unsigned(primitive_value)));
}

__attribute__((pure)) constexpr inline isize pow(u32 rhs) const& noexcept {
  const auto out =
      __private::pow_with_overflow(primitive_value, rhs.primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

__attribute__((pure)) constexpr Option<isize> checked_pow(u32 rhs) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, rhs.primitive_value);

if (!out.overflow) [[likely]]
 return Option<isize>(out.value);
 else
 return Option<isize>();
}

template <int&..., class Tuple = ::sus::tuple_type::Tuple<isize, bool>>
__attribute__((pure)) constexpr Tuple overflowing_pow(u32 exp) const& noexcept {
 const auto out =
 __private::pow_with_overflow(primitive_value, exp.primitive_value);
 return Tuple(out.value, out.overflow);
}

__attribute__((pure)) constexpr isize wrapping_pow(u32 exp) const& noexcept {
  return __private::wrapping_pow(primitive_value, exp.primitive_value);
}

__attribute__((pure)) constexpr Option<u32> checked_log2() const& noexcept {
 if (primitive_value <= 0) [[unlikely]] {
 return Option<u32>();
 } else {
 uint32_t zeros = __private::leading_zeros_nonzero(
 ::sus::marker::unsafe_fn, __private::into_unsigned(primitive_value));
 return Option<u32>(u32(__private::num_bits< ::sus::num::__private::addr_type<>::signed_type>()) - 1_u32 -
 u32(zeros));
 }
}

__attribute__((pure)) constexpr u32 log2() const& noexcept {

return checked_log2().unwrap();
}

__attribute__((pure)) constexpr u32 log10() const& noexcept {

return checked_log10().unwrap();
}

__attribute__((pure)) constexpr Option<u32> checked_log(isize base) const& noexcept {
 if (primitive_value <= 0 || base.primitive_value <= 1) [[unlikely]] {
 return Option<u32>();
 } else {
 auto n = uint32_t{0};
 auto r = primitive_value;
 const auto b = base.primitive_value;
 while (r >= b) {
 r /= b;
 n += 1u;
 }
 return Option<u32>(n);
 }
}

__attribute__((pure)) constexpr u32 log(isize base) const& noexcept {
  return checked_log(base).unwrap();
}

__attribute__((pure)) static constexpr isize from_be(isize x) noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) static constexpr isize from_le(isize x) noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return x;
  else
    return x.swap_bytes();
}

__attribute__((pure)) constexpr isize to_be() const& noexcept {
  if constexpr (std::endian::native == std::endian::big)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr isize to_le() const& noexcept {
  if constexpr (std::endian::native == std::endian::little)
    return *this;
  else
    return swap_bytes();
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static constexpr isize from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr isize from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>&
 bytes) noexcept;

__attribute__((pure)) static constexpr isize from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of< ::sus::num::__private::addr_type<>::signed_type>()>&
 bytes) noexcept;

};

inline constexpr isize isize::MIN = isize(isize::MIN_PRIMITIVE);
inline constexpr isize isize::MAX = isize(isize::MAX_PRIMITIVE);
inline constexpr u32 isize::BITS = u32(__private::num_bits< ::sus::num::__private::addr_type<>::signed_type>());

template <class T, Signed S>
 requires(std::constructible_from<isize, S>)
__attribute__((const)) constexpr inline T* operator+(T* t, S offset) {
 return t + ptrdiff_t{offset};
}

template <class T>
constexpr inline T*& operator+=(T*& t, isize offset) {
 t += ptrdiff_t{offset};
 return t;
}

template <class T>
__attribute__((const)) constexpr inline T* operator-(T* t, isize offset) {
 return t - ptrdiff_t{offset};
}

template <class T>
constexpr inline T*& operator-=(T*& t, isize offset) {
 t -= ptrdiff_t{offset};
 return t;
}

template <class P, Integer U>
 requires((SignedPrimitiveInteger || SignedPrimitiveEnum) &&
 std::convertible_to<U, u64>)
[[nodiscard]] __attribute__((const)) constexpr inline P operator<<(P l, U r) noexcept {

return l << u64(r).primitive_value;
}

template <class P, Integer U>
 requires((SignedPrimitiveInteger || SignedPrimitiveEnum) &&
 !std::convertible_to<U, u64>)
constexpr inline P operator<<(P l, U r) noexcept = delete;

return l >> u64(r).primitive_value;
}

template <class P, Integer U>
 requires((SignedPrimitiveInteger || SignedPrimitiveEnum) &&
 !std::convertible_to<U, u64>)
constexpr inline P operator>>(P l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i8 operator<<(
 i8 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shl_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i8 operator<<(i8 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i8 operator>>(
 i8 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shr_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i8 operator>>(i8 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i16 operator<<(
 i16 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shl_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i16 operator<<(i16 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i16 operator>>(
 i16 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shr_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i16 operator>>(i16 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i32 operator<<(
 i32 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shl_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i32 operator<<(i32 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i32 operator>>(
 i32 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shr_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i32 operator>>(i32 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i64 operator<<(
 i64 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shl_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i64 operator<<(i64 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline i64 operator>>(
 i64 l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shr_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline i64 operator>>(i64 l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline isize operator<<(
 isize l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shl_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline isize operator<<(isize l, U r) noexcept = delete;

[[nodiscard]] __attribute__((const)) constexpr inline isize operator>>(
 isize l, std::convertible_to<u64> auto r) noexcept {
 const auto out =
 __private::shr_with_overflow(l.primitive_value, u64(r).primitive_value);

::sus::check(!out.overflow);
  return out.value;
}

template <class U>
 requires(!std::convertible_to<U, u64>)
constexpr inline isize operator>>(isize l, U r) noexcept = delete;

}

::sus::num::i8 inline consteval operator""_i8(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::i8::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::i8(static_cast<decltype(::sus::num::i8::primitive_value)>(val)); };

::sus::num::i16 inline consteval operator""_i16(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::i16::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::i16(static_cast<decltype(::sus::num::i16::primitive_value)>(val)); };

::sus::num::i32 inline consteval operator""_i32(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::i32::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::i32(static_cast<decltype(::sus::num::i32::primitive_value)>(val)); };

::sus::num::i64 inline consteval operator""_i64(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::i64::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::i64(static_cast<decltype(::sus::num::i64::primitive_value)>(val)); };

::sus::num::isize inline consteval operator""_isize(unsigned long long val) { if (val > static_cast<unsigned long long>(::sus::num::isize::MAX_PRIMITIVE)) throw "Integer literal out of bounds for ##T##"; return ::sus::num::isize(static_cast<decltype(::sus::num::isize::primitive_value)>(val)); };

namespace sus {
using sus::num::i16;
using sus::num::i32;
using sus::num::i64;
using sus::num::i8;
using sus::num::isize;
}

namespace sus::ptr {

template <class T>
 requires(!std::is_reference_v<T>)
class [[clang::trivial_abi]] NonNull {
 public:

explicit constexpr NonNull(T& t) noexcept : ptr_(::sus::mem::addressof(t)) {}

template <::sus::ptr::SameOrSubclassOf<T*> U>
 static constexpr inline ::sus::option::Option<NonNull> with_ptr(
 U t) noexcept {
 if (t != nullptr) [[likely]]
 return ::sus::option::Option<NonNull>(NonNull(*t));
 else
 return ::sus::option::Option<NonNull>();
 }

template <class U, size_t N>
 static constexpr inline ::sus::option::Option<NonNull> with_ptr(U (&t)[N]) =
 delete;

template <::sus::ptr::SameOrSubclassOf<T*> U>
 static constexpr inline __attribute__((nonnull)) NonNull
 with_ptr_unchecked(::sus::marker::UnsafeFnMarker,
 U _Nonnull t) noexcept {
 return NonNull(*t);
 }

template <class U, size_t N>
 static constexpr inline NonNull with_ptr_unchecked(U (&t)[N]) = delete;

static constexpr inline NonNull from(T& t) noexcept { return NonNull(t); }

template <class U, size_t N>
 static constexpr inline NonNull from(U (&t)[N]) = delete;

const T* operator->() const noexcept { return ptr_; }
 T* operator->()
 requires(!std::is_const_v<T>)
 {
 return ptr_;
 }

constexpr inline const T& as_ref() const noexcept { return *ptr_; }

constexpr inline T& as_mut() noexcept
 requires(!std::is_const_v<T>)
 {
 return *ptr_;
 }

constexpr inline const T* as_ptr() const noexcept { return ptr_; }

constexpr inline T* as_mut_ptr() noexcept
 requires(!std::is_const_v<T>)
 {
 return ptr_;
 }

template <class U>
 requires ::sus::ptr::SameOrSubclassOf<T*, U*>
 NonNull cast() const noexcept {
 return NonNull::with_ptr_unchecked(::sus::marker::unsafe_fn,
 static_cast<U*>(ptr_));
 }

template <class U>
 NonNull downcast(::sus::marker::UnsafeFnMarker) const noexcept {
 return NonNull::with_ptr_unchecked(::sus::marker::unsafe_fn,
 static_cast<U*>(ptr_));
 }

private:
  T* ptr_;

explicit constexpr NonNull(::sus::mem::NeverValueConstructor) noexcept
      : ptr_(nullptr) {}
};

template <class T, class U>
 requires(::sus::cmp::Eq<const T*, const U*>)
constexpr inline bool operator==(const NonNull<T>& l,
 const NonNull& r) noexcept {
 return l.as_ptr() == r.as_ptr();
}

template <class T, class U>
 requires(::sus::cmp::StrongOrd<const T*, const U*>)
constexpr inline std::strong_ordering operator<=>(
 const NonNull<T>& l, const NonNull& r) noexcept {
 return l.as_ptr() <=> r.as_ptr();
}

}

template <class T, class Char>
struct fmt::formatter<::sus::ptr::NonNull<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::ptr::NonNull<T>& t,
 FormatContext& ctx) const {
 return underlying_.format(t.as_ptr(), ctx);
 }

private:
 formatter<void*, Char> underlying_;
};

namespace sus::ptr { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const NonNull <T>& value ) { static_assert(fmt::is_formattable<NonNull <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus::collections {

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] SliceIter final
 : public ::sus::iter::IteratorBase<SliceIter<ItemT>, ItemT> {
 public:
 using Item = ItemT;

private:

static_assert(std::is_reference_v<Item>);
 static_assert(std::is_const_v<std::remove_reference_t<Item>>);

using RawItem = std::remove_const_t<std::remove_reference_t<Item>>;

public:
  explicit constexpr SliceIter(::sus::iter::IterRef ref, const RawItem* start,
                               usize len) noexcept
      : ref_(::sus::move(ref)), ptr_(start), end_(start + len) {

::sus::check(end_ >= ptr_);
  }

constexpr Slice<Item> as_slice() const& {
 return Slice<Item>::from_raw_collection(::sus::marker::unsafe_fn, ptr_,
 end_ - ptr_);
 }

constexpr Option<Item> next() noexcept {
 if (ptr_ == end_) [[unlikely]]
 return Option<Item>();

return Option<Item>(*::sus::mem::replace(ptr_, ptr_ + 1u));
 }

constexpr Option<Item> next_back() noexcept {
 if (ptr_ == end_) [[unlikely]]
 return Option<Item>();

end_ -= 1u;
 return Option<Item>(*end_);
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return ::sus::iter::SizeHint(remaining,
 ::sus::Option<::sus::num::usize>(remaining));
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {

return ::sus::num::usize::try_from(end_ - ptr_)
        .unwrap_unchecked(::sus::marker::unsafe_fn);
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:
  [[no_unique_address]] ::sus::iter::IterRef ref_;
  const RawItem* ptr_;
  const RawItem* end_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ptr_), decltype(end_), decltype(ref_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

static_assert(::sus::mem::Copy<SliceIter<const i32&>>);
static_assert(::sus::mem::Move<SliceIter<const i32&>>);

template <class ItemT>
struct [[clang::trivial_abi]] SliceIterMut final
 : public ::sus::iter::IteratorBase<SliceIterMut<ItemT>, ItemT> {
 public:
 using Item = ItemT;

private:

static_assert(std::is_reference_v<Item>);
 static_assert(!std::is_const_v<std::remove_reference_t<Item>>);

using RawItem = std::remove_reference_t<Item>;

public:
  explicit constexpr SliceIterMut(::sus::iter::IterRef ref, RawItem* start,
                                  usize len) noexcept
      : ref_(::sus::move(ref)), ptr_(start), end_(start + len) {

::sus::check(end_ >= ptr_);
  }

constexpr SliceMut<RawItem> as_mut_slice() && {
 return SliceMut<RawItem>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, ref_.to_view(), ptr_,

usize::try_from(end_ - ptr_)
            .unwrap_unchecked(::sus::marker::unsafe_fn));
  }

constexpr Option<Item> next() noexcept {
 if (ptr_ == end_) [[unlikely]]
 return Option<Item>();

return Option<Item>(*::sus::mem::replace(ptr_, ptr_ + 1u));
 }

constexpr Option<Item> next_back() noexcept {
 if (ptr_ == end_) [[unlikely]]
 return Option<Item>();

end_ -= 1u;
 return Option<Item>(*end_);
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr usize exact_size_hint() const noexcept {

return usize::try_from(end_ - ptr_)
        .unwrap_unchecked(::sus::marker::unsafe_fn);
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:
  [[no_unique_address]] ::sus::iter::IterRef ref_;
  RawItem* ptr_;
  RawItem* end_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ptr_), decltype(end_), decltype(ref_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

static_assert(::sus::mem::Copy<SliceIterMut<i32&>>);
static_assert(::sus::mem::Move<SliceIterMut<i32&>>);

}

namespace sus::mem {

template <class T>
 requires(sus::mem::Move<T> && !std::is_const_v<T>)
inline constexpr void swap(T& lhs, T& rhs) noexcept {
 if (::sus::mem::addressof(lhs) != ::sus::mem::addressof(rhs)) [[likely]] {
 if constexpr (::sus::mem::relocate_by_memcpy<T>) {

if (!std::is_constant_evaluated()) {
 constexpr auto data_size = ::sus::mem::data_size_of<T>();
 char temp[data_size];
 ::sus::ptr::copy_nonoverlapping(
 ::sus::marker::unsafe_fn,
 reinterpret_cast<char*>(::sus::mem::addressof(lhs)), temp,
 data_size);
 ::sus::ptr::copy_nonoverlapping(
 ::sus::marker::unsafe_fn,
 reinterpret_cast<char*>(::sus::mem::addressof(rhs)),
 reinterpret_cast<char*>(::sus::mem::addressof(lhs)), data_size);
 ::sus::ptr::copy_nonoverlapping(
 ::sus::marker::unsafe_fn, temp,
 reinterpret_cast<char*>(::sus::mem::addressof(rhs)), data_size);
 return;
 }
 }
 auto temp = T(::sus::move(lhs));
 lhs = ::sus::move(rhs);
 rhs = ::sus::move(temp);
 }
}

template <class T>
 requires(sus::mem::Move<T> && !std::is_const_v<T>)
inline constexpr void swap_nonoverlapping(::sus::marker::UnsafeFnMarker, T& lhs,
 T& rhs) noexcept {
 if constexpr (::sus::mem::relocate_by_memcpy<T>) {

if (!std::is_constant_evaluated()) {
 constexpr auto data_size = ::sus::mem::data_size_of<T>();
 alignas(alignof(T)) char temp[data_size];
 char* l = reinterpret_cast<char*>(::sus::mem::addressof(lhs));
 char* r = reinterpret_cast<char*>(::sus::mem::addressof(rhs));
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, l, temp,
 data_size);
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, r, l,
 data_size);
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, temp, r,
 data_size);
 return;
 }
 }

T& l = lhs;
  T& r = rhs;
  auto temp = T(::sus::move(l));
  l = ::sus::move(r);
  r = ::sus::move(temp);
}

}

namespace sus::collections::__private {

template <class U, class Key, class T, ::sus::fn::FnMut<Key(const T&)> KeyFn>
void sort_slice_by_cached_key(const ::sus::collections::SliceMut<T>& slice,
 KeyFn& f) noexcept {
 auto indices =
 slice.iter()
 .map(f)
 .enumerate()
 .map([](::sus::Tuple<usize, Key>&& t) {
 auto&& [i, k] = ::sus::move(t);
 return ::sus::Tuple<Key, U>(::sus::forward<Key>(k), i);
 })
 .collect_vec();

indices.sort_unstable();
 const usize length = slice.len();
 for (usize i; i < length; i += 1u) {
 auto index = indices[i].template at<1>();
 while (index < i) {
 index = indices[index].template at<1>();
 }
 indices[i].template at_mut<1>() = index;
 slice.swap_unchecked(::sus::marker::unsafe_fn, i, index);
 }
};

}

namespace sus::collections {

template <class T>
concept Concat = requires(const T& t, const ::sus::num::usize& cap) {

{ t.len() } -> std::same_as<::sus::num::usize>;

typename T::ConcatOutputType;

{
 T::ConcatOutputType::with_capacity(cap)
 } -> std::same_as<typename T::ConcatOutputType>;

requires requires(typename T::ConcatOutputType & collection) {
 { t.concat_into(collection) } -> std::same_as<void>;
 };
};

}

namespace sus::collections {

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] Chunks final
 : public ::sus::iter::IteratorBase<Chunks<ItemT>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

private:

using SliceItem = ItemT;

public:

Option<Item> next() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return Option<Item>();
 } else {
 auto chunksz = ::sus::cmp::min(v_.len(), chunk_size_);
 auto [fst, snd] =
 v_.split_at_unchecked(::sus::marker::unsafe_fn, chunksz);
 v_ = snd;
 return Option<Item>(fst);
 }
 }

Option<Item> next_back() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {
 const auto len = v_.len();
 const auto remainder = len % chunk_size_;
 const auto chunksz = remainder != 0u ? remainder : chunk_size_;

auto [fst, snd] =
 v_.split_at_unchecked(::sus::marker::unsafe_fn, len - chunksz);
 v_ = fst;
 return ::sus::Option<Item>(snd);
 }
 }

::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

::sus::num::usize exact_size_hint() const noexcept {
    if (v_.is_empty()) {
      return 0u;
    } else {
      ::sus::num::usize n = v_.len() / chunk_size_;
      ::sus::num::usize rem = v_.len() % chunk_size_;
      return rem > 0u ? n + 1u : n;
    }
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr Chunks(::sus::iter::IterRef ref, const Slice<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)), v_(values), chunk_size_(chunk_size) {
 ::sus::check(chunk_size > 0u);
 }

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] ChunksMut final
 : public ::sus::iter::IteratorBase<ChunksMut<ItemT>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

private:
 static_assert(!std::is_reference_v<ItemT>);
 static_assert(!std::is_const_v<ItemT>);

using SliceItem = ItemT;

public:

Option<Item> next() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return Option<Item>();
 } else {
 const auto chunksz = ::sus::cmp::min(v_.len(), chunk_size_);
 auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, chunksz);
 v_ = snd;
 return Option<SliceMut<ItemT>>(fst);
 }
 }

auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, len - chunksz);
 v_ = fst;
 return ::sus::Option<Item>(snd);
 }
 }

::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

::sus::num::usize exact_size_hint() const noexcept {
    if (v_.is_empty()) {
      return 0u;
    } else {
      const auto n = v_.len() / chunk_size_;
      const auto rem = v_.len() % chunk_size_;
      return rem > 0u ? n + 1u : n;
    }
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr ChunksMut(::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)), v_(values), chunk_size_(chunk_size) {
 ::sus::check(chunk_size > 0u);
 }

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] ChunksExact final
 : public ::sus::iter::IteratorBase<ChunksExact<ItemT>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

private:

using SliceItem = ItemT;

public:

[[nodiscard]] Item remainder() const& { return rem_; }

constexpr Option<Item> next() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return Option<Item>();
 } else {

auto [fst, snd] =
 v_.split_at_unchecked(::sus::marker::unsafe_fn, chunk_size_);
 v_ = ::sus::move(snd);
 return Option<Item>(::sus::move(fst));
 }
 }

constexpr Option<Item> next_back() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {

auto [fst, snd] = v_.split_at_unchecked(
 ::sus::marker::unsafe_fn,
 v_.len().unchecked_sub(::sus::marker::unsafe_fn, chunk_size_));
 v_ = ::sus::move(fst);
 return ::sus::Option<Item>(::sus::move(snd));
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return v_.len() / chunk_size_;
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

static constexpr auto with_slice(::sus::iter::IterRef ref,
 const Slice<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept {
 ::sus::check(chunk_size > 0u);
 auto rem = values.len() % chunk_size;

auto fst_len = values.len().unchecked_sub(::sus::marker::unsafe_fn, rem);

auto [fst, snd] =
        values.split_at_unchecked(::sus::marker::unsafe_fn, fst_len);
    return ChunksExact(CONSTRUCT, ::sus::move(ref), fst, snd, chunk_size);
  }

enum Construct { CONSTRUCT };
 constexpr ChunksExact(Construct, ::sus::iter::IterRef ref,
 const Slice<ItemT>& values,
 const Slice<ItemT>& remainder,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 rem_(remainder),
 chunk_size_(chunk_size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 Slice<ItemT> rem_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(rem_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] ChunksExactMut final
 : public ::sus::iter::IteratorBase<ChunksExactMut<ItemT>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

private:

using SliceItem = ItemT;

public:

[[nodiscard]] constexpr Item remainder() const& { return rem_; }

constexpr Option<Item> next() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return Option<Item>();
 } else {

auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, chunk_size_);
 v_ = snd;
 return Option<Item>(fst);
 }
 }

constexpr Option<Item> next_back() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {

auto [fst, snd] = v_.split_at_mut_unchecked(
 ::sus::marker::unsafe_fn,
 v_.len().unchecked_sub(::sus::marker::unsafe_fn, chunk_size_));
 v_ = fst;
 return ::sus::Option<Item>(snd);
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return v_.len() / chunk_size_;
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

static constexpr auto with_slice(::sus::iter::IterRef ref,
 const SliceMut<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept {
 ::sus::check(chunk_size > 0u);
 auto rem = values.len() % chunk_size;

auto fst_len = values.len().unchecked_sub(::sus::marker::unsafe_fn, rem);

auto [fst, snd] =
        values.split_at_mut_unchecked(::sus::marker::unsafe_fn, fst_len);
    return ChunksExactMut(CONSTRUCT, ::sus::move(ref), fst, snd, chunk_size);
  }

enum Construct { CONSTRUCT };
 constexpr ChunksExactMut(Construct, ::sus::iter::IterRef ref,
 const SliceMut<ItemT>& values,
 const SliceMut<ItemT>& remainder,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 rem_(remainder),
 chunk_size_(chunk_size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 SliceMut<ItemT> rem_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(rem_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] RChunks final
 : public ::sus::iter::IteratorBase<RChunks<ItemT>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

private:

using SliceItem = ItemT;

public:

constexpr Option<Item> next() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return Option<Item>();
 } else {
 const auto len = v_.len();
 const auto chunksz = ::sus::cmp::min(len, chunk_size_);

const auto mid = len.unchecked_sub(::sus::marker::unsafe_fn, chunksz);

auto [fst, snd] = v_.split_at_unchecked(::sus::marker::unsafe_fn, mid);
 v_ = fst;
 return Option<Item>(snd);
 }
 }

constexpr Option<Item> next_back() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {
 const auto remainder = v_.len() % chunk_size_;
 const auto chunksz = remainder != 0u ? remainder : chunk_size_;

auto [fst, snd] =
 v_.split_at_unchecked(::sus::marker::unsafe_fn, chunksz);
 v_ = snd;
 return ::sus::Option<Item>(fst);
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    if (v_.is_empty()) {
      return 0u;
    } else {
      ::sus::num::usize n = v_.len() / chunk_size_;
      ::sus::num::usize rem = v_.len() % chunk_size_;
      return rem > 0u ? n + 1u : n;
    }
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr RChunks(::sus::iter::IterRef ref, const Slice<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)), v_(values), chunk_size_(chunk_size) {
 ::sus::check(chunk_size > 0u);
 }

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] RChunksMut final
 : public ::sus::iter::IteratorBase<RChunksMut<ItemT>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

private:
 static_assert(!std::is_reference_v<ItemT>);
 static_assert(!std::is_const_v<ItemT>);

using SliceItem = ItemT;

public:

constexpr Option<Item> next() noexcept {
 if (v_.is_empty()) [[unlikely]] {
 return Option<Item>();
 } else {
 const auto len = v_.len();
 auto chunksz = ::sus::cmp::min(len, chunk_size_);

const auto mid = len.unchecked_sub(::sus::marker::unsafe_fn, chunksz);

auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, mid);
 v_ = fst;
 return Option<SliceMut<ItemT>>(snd);
 }
 }

auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, chunksz);
 v_ = snd;
 return ::sus::Option<Item>(fst);
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    if (v_.is_empty()) {
      return 0u;
    } else {
      const auto n = v_.len() / chunk_size_;
      const auto rem = v_.len() % chunk_size_;
      return rem > 0u ? n + 1u : n;
    }
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr RChunksMut(::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)), v_(values), chunk_size_(chunk_size) {
 ::sus::check(chunk_size > 0u);
 }

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] RChunksExact final
 : public ::sus::iter::IteratorBase<RChunksExact<ItemT>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

private:

using SliceItem = ItemT;

public:

[[nodiscard]] constexpr Item remainder() const& { return rem_; }

constexpr Option<Item> next() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return Option<Item>();
 } else {

const auto mid =
          v_.len().unchecked_sub(::sus::marker::unsafe_fn, chunk_size_);

auto [fst, snd] = v_.split_at_unchecked(::sus::marker::unsafe_fn, mid);
 v_ = fst;
 return Option<Item>(snd);
 }
 }

constexpr Option<Item> next_back() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {

auto [fst, snd] =
 v_.split_at_unchecked(::sus::marker::unsafe_fn, chunk_size_);
 v_ = snd;
 return ::sus::Option<Item>(fst);
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return v_.len() / chunk_size_;
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

auto [fst, snd] = values.split_at_unchecked(::sus::marker::unsafe_fn, rem);
    return RChunksExact(CONSTRUCT, ::sus::move(ref), snd, fst, chunk_size);
  }

enum Construct { CONSTRUCT };
 constexpr RChunksExact(Construct, ::sus::iter::IterRef ref,
 const Slice<ItemT>& values,
 const Slice<ItemT>& remainder,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 rem_(remainder),
 chunk_size_(chunk_size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 Slice<ItemT> rem_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(rem_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
struct [[nodiscard]] [[clang::trivial_abi]] RChunksExactMut final
 : public ::sus::iter::IteratorBase<RChunksExactMut<ItemT>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

private:

using SliceItem = ItemT;

public:

[[nodiscard]] constexpr Item remainder() const& { return rem_; }

constexpr Option<Item> next() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return Option<Item>();
 } else {

auto [fst, snd] = v_.split_at_mut_unchecked(::sus::marker::unsafe_fn,
 v_.len() - chunk_size_);
 v_ = fst;
 return Option<Item>(snd);
 }
 }

constexpr Option<Item> next_back() noexcept {
 if (v_.len() < chunk_size_) [[unlikely]] {
 return ::sus::Option<Item>();
 } else {

auto [fst, snd] =
 v_.split_at_mut_unchecked(::sus::marker::unsafe_fn, chunk_size_);
 v_ = snd;
 return ::sus::Option<Item>(fst);
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return v_.len() / chunk_size_;
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

static constexpr auto with_slice(::sus::iter::IterRef ref,
 const SliceMut<ItemT>& values,
 ::sus::num::usize chunk_size) noexcept {
 ::sus::check(chunk_size > 0u);
 auto rem = values.len() % chunk_size;

auto [fst, snd] =
        values.split_at_mut_unchecked(::sus::marker::unsafe_fn, rem);
    return RChunksExactMut(::sus::move(ref), snd, fst, chunk_size);
  }

constexpr RChunksExactMut(::sus::iter::IterRef ref,
 const SliceMut<ItemT>& values,
 const SliceMut<ItemT>& remainder,
 ::sus::num::usize chunk_size) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 rem_(remainder),
 chunk_size_(chunk_size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 SliceMut<ItemT> rem_;
 ::sus::num::usize chunk_size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(rem_), decltype(chunk_size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

}

namespace sus::iter::__private {

template <::sus::num::IntegerNumeric T>
constexpr T step_max() noexcept {
 return T::MAX;
}
template <::sus::num::IntegerNumeric T>
constexpr T step_forward(T l) noexcept {

return l + T::try_from(1).unwrap_unchecked(::sus::marker::unsafe_fn);
}
template <::sus::num::IntegerNumeric T>
constexpr T step_backward(T l) noexcept {

return l - T::try_from(1).unwrap_unchecked(::sus::marker::unsafe_fn);
}
template <::sus::num::IntegerNumeric T>
constexpr ::sus::Option<::sus::num::usize> steps_between(const T& l,
 const T& r) noexcept {
 return r.checked_sub(l).and_then(
 [](T steps) { return ::sus::num::usize::try_from(steps).ok(); });
}

template <::sus::num::IntegerPointer T>
constexpr T step_max() noexcept {

return T::MAX_BIT_PATTERN;
}
template <::sus::num::IntegerPointer T>
constexpr T step_forward(T l) noexcept {
 return l + usize(1u);
}
template <::sus::num::IntegerPointer T>
constexpr T step_backward(T l) noexcept {
 return l - usize(1u);
}
template <::sus::num::IntegerPointer T>
constexpr ::sus::Option<::sus::num::usize> steps_between(const T& l,
 const T& r) noexcept {
 return r.checked_sub(l).and_then(
 [](T steps) { return ::sus::num::usize::try_from(steps).ok(); });
}

template <::sus::num::PrimitiveInteger T>
constexpr T step_max() noexcept {
 return ::sus::num::__private::max_value<T>();
}

template <::sus::num::PrimitiveInteger T>
constexpr T step_forward(T l) noexcept {
 ::sus::check(l < ::sus::num::__private::max_value<T>());

return l + T(1);
}
template <::sus::num::PrimitiveInteger T>
constexpr T step_backward(T l) noexcept {
 ::sus::check(l > ::sus::num::__private::min_value<T>());

return l - T(1);
}
template <::sus::num::PrimitiveInteger T>
constexpr ::sus::Option<::sus::num::usize> steps_between(const T& l,
 const T& r) noexcept {
 if (r >= l) {
 return ::sus::num::usize::try_from(r - l).ok();
 } else {
 return sus::none();
 }
}

template <class T>
concept Step = requires(const T& t, ::sus::num::usize n) {

{ ::sus::iter::__private::step_max<T>() } noexcept -> std::same_as<T>;
 { ::sus::iter::__private::step_forward(t) } noexcept -> std::same_as<T>;
 { ::sus::iter::__private::step_backward(t) } noexcept -> std::same_as<T>;

{
 ::sus::iter::__private::steps_between(t, t)
 } noexcept -> std::same_as<::sus::Option<::sus::num::usize>>;
};

}

namespace sus::ops {

template <class T, class I>
concept RangeBounds = requires(const T& t, T& v, const I& i) {
 { t.start_bound() } -> std::same_as<::sus::option::Option<const I&>>;
 { t.end_bound() } -> std::same_as<::sus::option::Option<const I&>>;

requires !requires { ::sus::move(v).start_bound(); };
 requires !requires { ::sus::move(v).end_bound(); };
 { t.contains(i) } -> std::same_as<bool>;

{ ::sus::move(v).start_at(i) };
  { ::sus::move(v).end_at(i) };

requires sus::mem::Copy<T> || !requires { t.start_at(i); };
 requires sus::mem::Copy<T> || !requires { t.end_at(i); };
 requires sus::mem::Copy<T> || !requires { v.start_at(i); };
 requires sus::mem::Copy<T> || !requires { v.end_at(i); };

requires !sus::mem::Copy<T> || requires { t.start_at(i); };
 requires !sus::mem::Copy<T> || requires { t.end_at(i); };
 requires !sus::mem::Copy<T> || requires { v.start_at(i); };
 requires !sus::mem::Copy<T> || requires { v.end_at(i); };
};

namespace __private {

template <class Final, class T, bool = ::sus::iter::__private::Step<T>>
class RangeIter;

template <class Final, class T>
class RangeIter<Final, T, true> : public ::sus::iter::IteratorBase<Final, T> {
 public:
 using Item = T;

constexpr Option<T> next() noexcept {
 if (static_cast<Final*>(this)->start == static_cast<Final*>(this)->finish)
 return Option<T>();
 return Option<T>(
 ::sus::mem::replace(static_cast<Final*>(this)->start,
 ::sus::iter::__private::step_forward(
 static_cast<Final*>(this)->start)));
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const usize rem = exact_size_hint();
 return ::sus::iter::SizeHint(rem, ::sus::Option<usize>(rem));
 }

constexpr usize exact_size_hint() const noexcept {
 Option<usize> steps = ::sus::iter::__private::steps_between(
 static_cast<const Final*>(this)->start,
 static_cast<const Final*>(this)->finish);
 return sus::move(steps).unwrap_or_default();
 }

constexpr Option<T> next_back() noexcept {
 if (static_cast<Final*>(this)->start == static_cast<Final*>(this)->finish)
 return Option<T>();
 static_cast<Final*>(this)->finish = ::sus::iter::__private::step_backward(
 static_cast<Final*>(this)->finish);
 return Option<T>(static_cast<Final*>(this)->finish);
 }

};

template <class Final, class T>
class RangeIter<Final, T, false> {
 constexpr auto begin() noexcept {
 static_assert(!std::same_as<T, T>,
 "Step<T> is not defined for the T that the range is over; "
 "use a range over an integer type to iterate");
 }
 constexpr auto end() noexcept {}
};

template <class Final, class T, bool = ::sus::iter::__private::Step<T>>
class RangeFromIter;

template <class Final, class T>
class RangeFromIter<Final, T, true>
 : public ::sus::iter::IteratorBase<Final, T> {
 public:
 using Item = T;

constexpr Option<T> next() noexcept {
 return Option<T>(
 ::sus::mem::replace(static_cast<Final*>(this)->start,
 ::sus::iter::__private::step_forward(
 static_cast<Final*>(this)->start)));
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 return ::sus::iter::SizeHint(::sus::iter::__private::step_max<T>(),
 ::sus::Option<::sus::num::usize>());
 }

};

template <class Final, class T>
class RangeFromIter<Final, T, false> {};

}

template <class T>
 requires(::sus::cmp::Ord<T>)
class Range final : public __private::RangeIter<Range<T>, T> {
 static_assert(!std::is_reference_v<T>,
 "Range must be over values, not references");

public:

T start;

T finish;

constexpr Range() noexcept
 requires(::sus::construct::Default<T>)
 = default;
 constexpr Range(T start, T finish) noexcept
 : start(::sus::move(start)), finish(::sus::move(finish)) {}

constexpr bool contains(const T& item) const noexcept {
 return start <= item && item < finish;
 }

constexpr ::sus::option::Option<const T&> start_bound() const& noexcept {
 return ::sus::option::Option<const T&>(start);
 }
 constexpr ::sus::option::Option<const T&> start_bound() && = delete;

constexpr ::sus::option::Option<const T&> end_bound() const& noexcept {
 return ::sus::option::Option<const T&>(finish);
 }
 constexpr ::sus::option::Option<const T&> end_bound() && = delete;

constexpr bool is_empty() const noexcept { return !(start < finish); }

constexpr Range start_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return Range(::sus::move(t), finish);
 }
 constexpr Range start_at(T t) && noexcept {
 return Range(::sus::move(t), ::sus::move(finish));
 }

constexpr Range end_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return Range(start, ::sus::move(t));
 }
 constexpr Range end_at(T t) && noexcept {
 return Range(::sus::move(start), ::sus::move(t));
 }

constexpr bool operator==(const Range& rhs) const noexcept
 requires(::sus::cmp::Eq<T>)
 {
 return start == rhs.start && finish == rhs.finish;
 }

};

template <class T>
 requires(::sus::cmp::Ord<T>)
class RangeFrom final : public __private::RangeFromIter<RangeFrom<T>, T> {
 static_assert(!std::is_reference_v<T>,
 "RangeFrom must be over values, not references");

public:

T start;

constexpr RangeFrom() noexcept
 requires(::sus::construct::Default<T>)
 = default;
 constexpr RangeFrom(T start) noexcept : start(::sus::move(start)) {}

constexpr bool contains(const T& item) const noexcept {
    return item >= start;
  }

constexpr ::sus::option::Option<const T&> start_bound() const& noexcept {
 return ::sus::option::Option<const T&>(start);
 }
 constexpr ::sus::option::Option<const T&> start_bound() && = delete;

constexpr ::sus::option::Option<const T&> end_bound() const& noexcept {
 return ::sus::option::Option<const T&>();
 }
 constexpr ::sus::option::Option<const T&> end_bound() && = delete;

constexpr RangeFrom start_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return RangeFrom(::sus::move(t));
 }
 constexpr RangeFrom start_at(T t) && noexcept {
 return RangeFrom(::sus::move(t));
 }

constexpr Range<T> end_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return Range<T>(start, ::sus::move(t));
 }
 constexpr Range<T> end_at(T t) && noexcept {
 return Range<T>(::sus::move(start), ::sus::move(t));
 }

constexpr bool operator==(const RangeFrom& rhs) const noexcept
 requires(::sus::cmp::Eq<T>)
 {
 return start == rhs.start;
 }

};

template <class T>
 requires(::sus::cmp::Ord<T>)
class RangeTo final {
 static_assert(!std::is_reference_v<T>,
 "RangeTo must be over values, not references");

public:

T finish;

constexpr RangeTo() noexcept
 requires(::sus::construct::Default<T>)
 = default;
 constexpr RangeTo(T finish) noexcept : finish(::sus::move(finish)) {}

constexpr bool contains(const T& item) const noexcept {
 return item < finish;
 }

constexpr ::sus::option::Option<const T&> start_bound() const& noexcept {
 return ::sus::option::Option<const T&>();
 }
 constexpr ::sus::option::Option<const T&> start_bound() && = delete;

constexpr ::sus::option::Option<const T&> end_bound() const& noexcept {
 return ::sus::option::Option<const T&>(finish);
 }
 constexpr ::sus::option::Option<const T&> end_bound() && = delete;

constexpr Range<T> start_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return Range<T>(::sus::move(t), finish);
 }
 constexpr Range<T> start_at(T t) && noexcept {
 return Range<T>(::sus::move(t), ::sus::move(finish));
 }

constexpr RangeTo end_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return RangeTo(::sus::move(t));
 }
 constexpr RangeTo end_at(T t) && noexcept { return RangeTo(::sus::move(t)); }

constexpr bool operator==(const RangeTo& rhs) const noexcept
 requires(::sus::cmp::Eq<T>)
 {
 return finish == rhs.finish;
 }

};

template <class T>
 requires(::sus::cmp::Ord<T>)
class [[clang::trivial_abi]] RangeFull final {
 static_assert(!std::is_reference_v<T>,
 "RangeFull must be over values, not references");

public:
  RangeFull() = default;

constexpr bool contains(const T&) const noexcept { return true; }

constexpr ::sus::option::Option<const T&> start_bound() const& noexcept {
 return ::sus::option::Option<const T&>();
 }
 constexpr ::sus::option::Option<const T&> start_bound() && = delete;

constexpr ::sus::option::Option<const T&> end_bound() const& noexcept {
 return ::sus::option::Option<const T&>();
 }
 constexpr ::sus::option::Option<const T&> end_bound() && = delete;

constexpr RangeFrom<T> start_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return RangeFrom<T>(::sus::move(t));
 }
 constexpr RangeFrom<T> start_at(T t) && noexcept {
 return RangeFrom<T>(::sus::move(t));
 }

constexpr RangeTo<T> end_at(T t) const& noexcept
 requires(::sus::mem::Copy<T>)
 {
 return RangeTo<T>(::sus::move(t));
 }
 constexpr RangeTo<T> end_at(T t) && noexcept {
 return RangeTo<T>(::sus::move(t));
 }

constexpr bool operator==(const RangeFull& rhs) const noexcept
 requires(::sus::cmp::Eq<T>)
 {
 return true;
 }

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");
};

template <class T>
constexpr inline Range<T> range(T start, T end) noexcept {
 return Range<T>(start, end);
}

template <class T>
constexpr inline RangeTo<T> range_to(T t) noexcept {
 return RangeTo<T>(t);
}

template <class T>
constexpr inline RangeFrom<T> range_from(T t) noexcept {
 return RangeFrom<T>(t);
}

}

template <class T, class Char>
struct fmt::formatter<::sus::ops::Range<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::ops::Range<T>& t,
 FormatContext& ctx) const {
 auto out = ctx.out();
 out = underlying_.format(t.start, ctx);
 *out++ = static_cast<Char>('.');
 *out++ = static_cast<Char>('.');
 out = underlying_.format(t.finish, ctx);
 return out;
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::ops { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const Range <T>& value ) { static_assert(fmt::is_formattable<Range <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

template <class T, class Char>
struct fmt::formatter<::sus::ops::RangeFrom<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::ops::RangeFrom<T>& t,
 FormatContext& ctx) const {
 auto out = ctx.out();
 out = underlying_.format(t.start, ctx);
 *out++ = static_cast<Char>('.');
 *out++ = static_cast<Char>('.');
 return out;
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::ops { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const RangeFrom <T>& value ) { static_assert(fmt::is_formattable<RangeFrom <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

template <class T, class Char>
struct fmt::formatter<::sus::ops::RangeTo<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::ops::RangeTo<T>& t,
 FormatContext& ctx) const {
 auto out = ctx.out();
 *out++ = static_cast<Char>('.');
 *out++ = static_cast<Char>('.');
 out = underlying_.format(t.finish, ctx);
 return out;
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::ops { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const RangeTo <T>& value ) { static_assert(fmt::is_formattable<RangeTo <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

template <class T, class Char>
struct fmt::formatter<::sus::ops::RangeFull<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::ops::RangeFull<T>&,
 FormatContext& ctx) const {
 auto out = ctx.out();
 *out++ = static_cast<Char>('.');
 *out++ = static_cast<Char>('.');
 return out;
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::ops { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const RangeFull <T>& value ) { static_assert(fmt::is_formattable<RangeFull <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus::collections {

namespace __private {

template <class ItemT, ::sus::iter::Iterator<ItemT> I>
class GenericSplitN final
 : public ::sus::iter::IteratorBase<GenericSplitN<ItemT, I>, ItemT> {
 public:
 using Item = ItemT;

constexpr explicit GenericSplitN(I&& iter, usize count)
      : iter_(::sus::move(iter)), count_(count) {}

constexpr Option<Item> next() noexcept {
 if (count_ == 0u)
 return Option<Item>();
 else if (count_ == 1u) {
 count_ -= 1u;
 return iter_.finish();
 } else {
 count_ -= 1u;
 return iter_.next();
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 auto [lower, upper_opt] = iter_.size_hint();
 const auto count = count_;
 return {::sus::cmp::min(count, lower),
 Option<usize>(
 ::sus::move(upper_opt).map_or(count, [count](usize upper) {
 return ::sus::cmp::min(count, upper);
 }))};
 }

private:
  I iter_;
  usize count_;

};

}

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] Split final
 : public ::sus::iter::IteratorBase<Split<ItemT, Pred>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

::sus::num::usize idx;
 auto it = v_.iter();
 while (true) {
 Option<const ItemT&> o = it.next();
 if (o.is_none()) {
 return finish();
 }
 if (::sus::fn::call_mut(pred_, *o)) {
 ret = Option<Item>(v_[::sus::ops::RangeTo(idx)]);
 v_ = v_[::sus::ops::RangeFrom(idx + 1u)];
 return ret;
 }
 idx += 1u;
 }
 }

constexpr Option<Item> next_back() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

::sus::num::usize idx = v_.len();
 auto it = v_.iter().rev();
 while (true) {
 Option<const ItemT&> o = it.next();
 if (o.is_none()) {
 return finish();
 }
 idx -= 1u;
 if (::sus::fn::call_mut(pred_, *o)) {
 ret = Option<Item>(v_[::sus::ops::RangeFrom(idx + 1u)]);
 v_ = v_[::sus::ops::RangeTo(idx)];
 return ret;
 }
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 if (v_.is_empty()) {
 return {0u, ::sus::Option<::sus::num::usize>(0u)};
 } else {

return {1u, ::sus::Option<::sus::num::usize>(
 ::sus::cmp::max(1_usize, v_.len()))};
 }
 }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

template <class A, ::sus::iter::Iterator<A> B>
 friend class __private::GenericSplitN;

template <class A, ::sus::fn::FnMut<bool(const A&)> APred>
 friend class RSplit;

constexpr Option<Item> finish() noexcept {
 if (finished_) {
 return Option<Item>();
 } else {
 finished_ = true;
 return Option<Item>(v_);
 }
 }

constexpr Split(::sus::iter::IterRef ref, const Slice<ItemT>& values,
 Pred&& pred) noexcept
 : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 Pred pred_;
 bool finished_ = false;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] SplitMut final
 : public ::sus::iter::IteratorBase<SplitMut<ItemT, Pred>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

constexpr Option<Item> next() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

constexpr Option<Item> next_back() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 if (v_.is_empty()) {
 return {0u, ::sus::Option<::sus::num::usize>(0u)};
 } else {

return {1u, ::sus::Option<::sus::num::usize>(
 ::sus::cmp::max(1_usize, v_.len()))};
 }
 }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

template <class A, ::sus::iter::Iterator<A> B>
 friend class __private::GenericSplitN;

template <class A, ::sus::fn::FnMut<bool(const A&)>>
 friend class RSplitMut;

constexpr Option<Item> finish() noexcept {
 if (finished_) {
 return Option<Item>();
 } else {
 finished_ = true;
 return Option<Item>(v_);
 }
 }

constexpr SplitMut(::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
 Pred&& pred) noexcept
 : ref_(::sus::move(ref)), v_(values), pred_(::sus::move(pred)) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 Pred pred_;
 bool finished_ = false;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] SplitInclusive final
 : public ::sus::iter::IteratorBase<SplitInclusive<ItemT, Pred>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

::sus::num::usize idx;
 const usize last = v_.len() - 1u;
 auto it = v_.iter();
 while (true) {
 Option<const ItemT&> o = it.next();
 if (o.is_none() || ::sus::fn::call_mut(pred_, *o)) {
 if (idx >= last) {
 finished_ = true;
 idx = last;
 }
 ret = Option<Item>(v_[::sus::ops::RangeTo(idx + 1u)]);
 v_ = v_[::sus::ops::RangeFrom(idx + 1u)];
 return ret;
 }
 idx += 1u;
 }
 }

constexpr Option<Item> next_back() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

const auto remainder =
 v_.is_empty() ? Slice<ItemT>() : v_[::sus::ops::RangeTo(v_.len() - 1u)];

::sus::num::usize idx = remainder.len();
 auto it = remainder.iter().rev();
 while (true) {
 Option<const ItemT&> o = it.next();
 if (o.is_none() || ::sus::fn::call_mut(pred_, *o)) {
 if (idx == 0u) {
 finished_ = true;
 }
 ret = Option<Item>(v_[::sus::ops::RangeFrom(idx)]);
 v_ = v_[::sus::ops::RangeTo(idx)];
 return ret;
 }
 idx -= 1u;
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 if (v_.is_empty()) {
 return {0u, ::sus::Option<::sus::num::usize>(0u)};
 } else {

return {1u, ::sus::Option<::sus::num::usize>(
 ::sus::cmp::max(1_usize, v_.len()))};
 }
 }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr SplitInclusive(::sus::iter::IterRef ref, const Slice<ItemT>& values,
 Pred&& pred) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 pred_(::sus::move(pred)),
 finished_(v_.is_empty()) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 Pred pred_;
 bool finished_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] SplitInclusiveMut final
 : public ::sus::iter::IteratorBase<SplitInclusiveMut<ItemT, Pred>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

constexpr Option<Item> next() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

constexpr Option<Item> next_back() noexcept {
 Option<Item> ret;

if (finished_) [[unlikely]] {
      return ret;
    }

const auto remainder = v_.is_empty()
 ? SliceMut<ItemT>()
 : v_[::sus::ops::RangeTo(v_.len() - 1u)];

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 if (v_.is_empty()) {
 return {0u, ::sus::Option<::sus::num::usize>(0u)};
 } else {

return {1u, ::sus::Option<::sus::num::usize>(
 ::sus::cmp::max(1_usize, v_.len()))};
 }
 }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr SplitInclusiveMut(::sus::iter::IterRef ref,
 const SliceMut<ItemT>& values,
 Pred&& pred) noexcept
 : ref_(::sus::move(ref)),
 v_(values),
 pred_(::sus::move(pred)),
 finished_(v_.is_empty()) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 Pred pred_;
 bool finished_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] RSplit final
 : public ::sus::iter::IteratorBase<RSplit<ItemT, Pred>,
 ::sus::collections::Slice<ItemT>> {
 public:
 using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next_back(); }

constexpr Option<Item> next_back() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

template <class A, ::sus::iter::Iterator<A> B>
 friend class __private::GenericSplitN;

constexpr Option<Item> finish() noexcept { return inner_.finish(); }

constexpr RSplit(Split<ItemT, Pred>&& split) noexcept
 : inner_(::sus::move(split)) {}

Split<ItemT, Pred> inner_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] RSplitMut final
 : public ::sus::iter::IteratorBase<RSplitMut<ItemT, Pred>,
 ::sus::collections::SliceMut<ItemT>> {
 public:
 using Item = ::sus::collections::SliceMut<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next_back(); }

constexpr Option<Item> next_back() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

template <class A, ::sus::iter::Iterator<A> B>
 friend class __private::GenericSplitN;

Option<Item> finish() noexcept { return inner_.finish(); }

constexpr RSplitMut(SplitMut<ItemT, Pred>&& split) noexcept
 : inner_(::sus::move(split)) {}

SplitMut<ItemT, Pred> inner_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] SplitN final
 : public ::sus::iter::IteratorBase<SplitN<ItemT, Pred>,
 ::sus::collections::Slice<ItemT>> {
 public:
 using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr SplitN(Split<ItemT, Pred> split, usize n) noexcept
 : inner_(::sus::move(split), n) {}

__private::GenericSplitN<Slice<ItemT>, Split<ItemT, Pred>> inner_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] SplitNMut final
 : public ::sus::iter::IteratorBase<SplitNMut<ItemT, Pred>,
 ::sus::collections::SliceMut<ItemT>> {
 public:
 using Item = ::sus::collections::SliceMut<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr SplitNMut(SplitMut<ItemT, Pred> split, usize n) noexcept
 : inner_(::sus::move(split), n) {}

__private::GenericSplitN<SliceMut<ItemT>, SplitMut<ItemT, Pred>> inner_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] RSplitN final
 : public ::sus::iter::IteratorBase<RSplitN<ItemT, Pred>,
 ::sus::collections::Slice<ItemT>> {
 public:
 using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr RSplitN(RSplit<ItemT, Pred> split, usize n) noexcept
 : inner_(::sus::move(split), n) {}

__private::GenericSplitN<Slice<ItemT>, RSplit<ItemT, Pred>> inner_;

};

template <class ItemT, ::sus::fn::FnMut<bool(const ItemT&)> Pred>
class [[nodiscard]] RSplitNMut final
 : public ::sus::iter::IteratorBase<RSplitNMut<ItemT, Pred>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

constexpr Option<Item> next() noexcept { return inner_.next(); }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
    return inner_.size_hint();
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr RSplitNMut(RSplitMut<ItemT, Pred> split, usize n) noexcept
 : inner_(::sus::move(split), n) {}

__private::GenericSplitN<SliceMut<ItemT>, RSplitMut<ItemT, Pred>> inner_;

};

}

namespace sus::collections {

template <class ItemT>
class [[nodiscard]] [[clang::trivial_abi]] Windows final
 : public ::sus::iter::IteratorBase<Windows<ItemT>,
 ::sus::collections::Slice<ItemT>> {
 public:

using Item = ::sus::collections::Slice<ItemT>;

constexpr Option<Item> next() noexcept {
 Option<Item> ret;

if (size_ > v_.len()) {
 return ret;
 } else {
 ret = Option<Item>(v_[::sus::ops::RangeTo<usize>(size_)]);
 v_ = v_[::sus::ops::RangeFrom<usize>(1u)];
 return ret;
 }
 }

constexpr Option<Item> next_back() noexcept {
 Option<Item> ret;

if (size_ > v_.len()) {
 return ret;
 } else {
 ret = Option<Item>(
 v_[::sus::ops::RangeFrom<usize>(v_.len() - size_)]);
 v_ = v_[::sus::ops::RangeTo<usize>(v_.len() - 1u)];
 return ret;
 }
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    if (size_ > v_.len()) {
      return 0u;
    } else {
      return v_.len() - size_ + 1u;
    }
  }

private:

friend class Slice<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr Windows(::sus::iter::IterRef ref, const Slice<ItemT>& values,
 usize size) noexcept
 : ref_(::sus::move(ref)), v_(values), size_(size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 Slice<ItemT> v_;
 usize size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class ItemT>
class [[nodiscard]] [[clang::trivial_abi]] WindowsMut final
 : public ::sus::iter::IteratorBase<WindowsMut<ItemT>,
 ::sus::collections::SliceMut<ItemT>> {
 public:

using Item = ::sus::collections::SliceMut<ItemT>;

WindowsMut(WindowsMut&&) = default;
  WindowsMut& operator=(WindowsMut&&) = default;

WindowsMut clone() const noexcept {
    return WindowsMut(::sus::clone(v_), ::sus::clone(size_));
  }

Option<Item> next() noexcept {
 Option<Item> ret;

if (size_ > v_.len()) {
 return ret;
 } else {
 ret = Option<Item>(v_[::sus::ops::RangeTo<usize>(size_)]);
 v_ = v_[::sus::ops::RangeFrom<usize>(1u)];
 return ret;
 }
 }

Option<Item> next_back() noexcept {
 Option<Item> ret;

::sus::iter::SizeHint size_hint() const noexcept {
 const auto remaining = exact_size_hint();
 return {remaining, ::sus::Option<::sus::num::usize>(remaining)};
 }

::sus::num::usize exact_size_hint() const noexcept {
    if (size_ > v_.len()) {
      return 0u;
    } else {
      return v_.len() - size_ + 1u;
    }
  }

private:

friend class SliceMut<ItemT>;
 friend class Vec<ItemT>;
 template <class ArrayItemT, size_t N>
 friend class Array;

constexpr WindowsMut(::sus::iter::IterRef ref, const SliceMut<ItemT>& values,
 usize size) noexcept
 : ref_(::sus::move(ref)), v_(values), size_(size) {}

[[no_unique_address]] ::sus::iter::IterRef ref_;
 SliceMut<ItemT> v_;
 usize size_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(ref_), decltype(v_), decltype(size_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

}

namespace sus::collections {

template <class T, class Sep>
concept Join = requires(const T& t, const ::sus::num::usize& cap) {

requires ::sus::mem::Clone<Sep>;

{ t.len() } -> std::same_as<::sus::num::usize>;

typename T::JoinOutputType;

{
 T::JoinOutputType::with_capacity(cap)
 } -> std::same_as<typename T::JoinOutputType>;
 requires requires(typename T::JoinOutputType& collection, const Sep& sep) {

{ t.join_into(collection) } -> std::same_as<void>;

{ T::join_sep_into(collection, sep) } -> std::same_as<void>;
 };
};

}

namespace sus::marker {

struct EmptyMarker {

explicit consteval EmptyMarker() {}
};

constexpr inline auto empty = EmptyMarker();

}

template <class Char>
struct fmt::formatter<::sus::marker::EmptyMarker, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return ctx.begin();
 }

template <class FormatContext>
 constexpr auto format(const ::sus::marker::EmptyMarker&,
 FormatContext& ctx) const {
 return fmt::format_to(ctx.out(), "empty");
 }
};

namespace sus::marker { using namespace ::sus::string::__private; template< StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const EmptyMarker & value ) { static_assert(fmt::is_formattable<EmptyMarker >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus {
using sus::marker::empty;
}

namespace sus::construct {

template <class To, class From>
struct TransmogrifyImpl;

template <::sus::mem::Copy T>
struct TransmogrifyImpl<T, T> {
 constexpr static T mog_from(const T& from) noexcept { return from; }
};

template <class To, class From>
concept Transmogrify = requires(const From& from) {
 {
 ::sus::construct::TransmogrifyImpl<
 std::remove_const_t<To>, std::remove_const_t<From>>::mog_from(from)
 } noexcept -> std::same_as<std::remove_const_t<To>>;
};

template <class To, class From>
 requires(Transmogrify<To, From>)
constexpr inline To mog(const From& from) {
 return TransmogrifyImpl<To, From>::mog_from(from);
}

}

namespace sus {
using ::sus::construct::mog;
}

template <sus::num::Integer T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 from.primitive_value));
 }
};

template <sus::num::Integer T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(from));
 }
};

template <sus::num::Integer T, sus::num::PrimitiveEnum F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::Integer T, sus::num::PrimitiveEnumClass F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::Integer T, sus::num::Float F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 from.primitive_value));
 }
};

template <sus::num::Integer T, sus::num::PrimitiveFloat F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(from));
 }
};

template <sus::num::PrimitiveInteger T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return ::sus::mog<T>(from.primitive_value);
 }
};

template <sus::num::PrimitiveInteger T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(from);
 }
};

template <sus::num::PrimitiveInteger T, sus::num::PrimitiveEnum F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(static_cast<std::underlying_type_t<F>>(from));
 }
};

template <sus::num::PrimitiveInteger T, sus::num::PrimitiveEnumClass F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(static_cast<std::underlying_type_t<F>>(from));
 }
};

template <sus::num::PrimitiveInteger T, sus::num::Float F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return ::sus::mog<T>(from.primitive_value);
 }
};

template <sus::num::PrimitiveInteger T, sus::num::PrimitiveFloat F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 if (::sus::num::__private::float_is_nan(from)) [[unlikely]]
 return T(0);
 if (from > ::sus::num::__private::max_int_float<T, F>()) [[unlikely]]
 return ::sus::num::__private::max_value<T>();
 if (from < ::sus::num::__private::min_int_float<T, F>()) [[unlikely]]
 return ::sus::num::__private::min_value<T>();

return static_cast<T>(from);
 }
};

template <sus::num::PrimitiveEnum T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(from));
 }
};

template <sus::num::PrimitiveEnum T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(from));
 }
};

template <sus::num::PrimitiveEnum T, sus::num::PrimitiveEnum F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::PrimitiveEnum T, sus::num::PrimitiveEnumClass F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::PrimitiveEnumClass T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(from));
 }
};

template <sus::num::PrimitiveEnumClass T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(from));
 }
};

template <sus::num::PrimitiveEnumClass T, sus::num::PrimitiveEnum F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::PrimitiveEnumClass T, sus::num::PrimitiveEnumClass F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return static_cast<T>(::sus::mog<std::underlying_type_t<T>>(
 static_cast<std::underlying_type_t<F>>(from)));
 }
};

template <sus::num::Float T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 from.primitive_value));
 }
};

template <sus::num::Float T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(from));
 }
};

template <sus::num::Float T, sus::num::Float F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(
 from.primitive_value));
 }
};

template <sus::num::Float T, sus::num::PrimitiveFloat F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return T(::sus::mog<decltype(std::declval<T>().primitive_value)>(from));
 }
};

template <sus::num::PrimitiveFloat T, sus::num::Integer F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return ::sus::mog<T>(from.primitive_value);
 }
};

template <sus::num::PrimitiveFloat T, sus::num::PrimitiveInteger F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return ::sus::num::__private::static_cast_int_to_float<float>(from);
 }
};

template <sus::num::PrimitiveFloat T, sus::num::Float F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 return ::sus::mog<T>(from.primitive_value);
 }
};

template <sus::num::PrimitiveFloat T, sus::num::PrimitiveFloat F>
struct sus::construct::TransmogrifyImpl<T, F> {
 constexpr static T mog_from(const F& from) noexcept {
 static_assert(::sus::mem::size_of<T>() == 4u ||
 ::sus::mem::size_of<T>() == 8u);
 static_assert(::sus::mem::size_of<F>() == 4u ||
 ::sus::mem::size_of<F>() == 8u);

if constexpr (::sus::mem::size_of<T>() == 4u) {
 if constexpr (::sus::mem::size_of<F>() == 4u) {
 return from;
 } else {
 return ::sus::num::__private::static_cast_to_smaller_float<float>(from);
 }
 } else {
 if constexpr (::sus::mem::size_of<F>() == 4u) {

return T{from};
      } else {
        return from;
      }
    }
  }
};

namespace sus::ptr {

template <class T>
 requires(sus::mem::Move<T> && !std::is_const_v<T>)
inline constexpr void swap_nonoverlapping(::sus::marker::UnsafeFnMarker, T* x,
 T* y, usize count) noexcept {

;
                               ;

if (!std::is_constant_evaluated()) {
                                                                     ;
                                                                     ;
  }

;

constexpr usize t_size = ::sus::mem::size_of<T>();

constexpr bool has_split_up_alignment = alignof(T) <= alignof(uintptr_t);

constexpr bool has_split_up_size =
 !t_size.is_power_of_two() ||
 t_size > ::sus::mem::size_of<uintptr_t>() * 2;

const ::sus::Option<usize> opt_byte_count = count.checked_mul(t_size);

if (std::is_constant_evaluated() || !::sus::mem::relocate_by_memcpy<T> ||
 !has_split_up_alignment || !has_split_up_size ||
 opt_byte_count.is_none()) {

for (usize i; i < count; i += 1u) {
 ::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(x + i),
 *(y + i));
 }
 return;
 }

const usize byte_count = *opt_byte_count;

if constexpr (alignof(T) == alignof(uintptr_t) &&
 t_size % ::sus::mem::size_of<uintptr_t>() == 0u) {
 char* const cx = reinterpret_cast<char*>(x);
 char* const cy = reinterpret_cast<char*>(y);
 alignas(alignof(uintptr_t)) char buf[::sus::mem::size_of<uintptr_t>()];
 for (usize i; i < byte_count; i += ::sus::mem::size_of<uintptr_t>()) {
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, cx + i, buf,
 ::sus::mem::size_of<uintptr_t>());
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, cy + i, cx + i,
 ::sus::mem::size_of<uintptr_t>());
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf, cy + i,
 ::sus::mem::size_of<uintptr_t>());
 }
 } else {

char* const cx = reinterpret_cast<char*>(x);
 char* const cy = reinterpret_cast<char*>(y);

;
 char buf;
 for (usize i; i < byte_count; i += 1u) {
 buf = *(cx + i);
 *(cx + i) = *(cy + i);
 *(cy + i) = buf;
 }
 }
}

}

namespace sus::collections {

template <class T>
class [[clang::trivial_abi]] Slice final {
 public:
 static_assert(!std::is_reference_v<T>,
 "Slice holds references, so the type parameter can not also be "
 "a reference");
 static_assert(!std::is_const_v<T>,
 "Slice inner type should not be const, it provides const "
 "access to the slice regardless.");

constexpr Slice(::sus::marker::EmptyMarker) : Slice() {}

explicit constexpr Slice()
      : Slice(::sus::iter::IterRefCounter::empty_for_view(), nullptr, 0_usize) {
  }

__attribute__((pure)) static constexpr inline Slice from_raw_parts(
 ::sus::marker::UnsafeFnMarker, const T* data [[clang::lifetimebound]],
 usize len) noexcept {
 ::sus::check(len <= ::sus::mog<usize>(isize::MAX));

return Slice(::sus::iter::IterRefCounter::empty_for_view(),
 const_cast<T*>(data), len);
 }

__attribute__((pure)) static constexpr inline Slice from_raw_collection(
 ::sus::marker::UnsafeFnMarker, ::sus::iter::IterRefCounter refs,
 const T* data [[clang::lifetimebound]], usize len) noexcept {
 ::sus::check(len <= ::sus::mog<usize>(isize::MAX));

return Slice(::sus::move(refs), const_cast<T*>(data), len);
 }

template <size_t N>
 requires(N <= ::sus::mog<usize>(isize::MAX))
 __attribute__((pure)) static constexpr inline Slice from(
 const T (&data)[N] [[clang::lifetimebound]]) {

return Slice(sus::iter::IterRefCounter::empty_for_view(),
 const_cast<T*>(data), N);
 }

__attribute__((pure)) constexpr SliceIter<const T&> into_iter() && noexcept {
 return SliceIter<const T&>(

iter_refs_.to_iter_from_view(), data_, len_);
  }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const Slice<T>& l,
 const Slice& r) noexcept {
 if (l.len() != r.len()) return false;
 for (usize i = l.len(); i > 0u; i -= 1u) {
 if (!(l[i - 1u] == r[i - 1u])) return false;
 }
 return true;
 }

template <class U>
 requires(!::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const Slice<T>& l,
 const Slice& r) = delete;

__attribute__((pure)) constexpr inline const T& operator[](usize i) const& noexcept {
 ::sus::check(i < len());
 return *(as_ptr() + i);
 }

__attribute__((pure)) constexpr inline Slice<T> operator[](
 const ::sus::ops::RangeBounds<usize> auto range) const& noexcept {
 const usize length = len();
 const usize rstart = range.start_bound().unwrap_or(0u);
 const usize rend = range.end_bound().unwrap_or(length);
 const usize rlen = rend >= rstart ? rend - rstart : 0u;
 ::sus::check(rlen <= length);

::sus::check(rstart <= length && rstart <= length - rlen);
 return Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_view(),
 as_ptr() + rstart, rlen);
 }

void drop_iterator_invalidation_tracking(::sus::marker::UnsafeFnMarker) {
    iter_refs_ = ::sus::iter::IterRefCounter::empty_for_view();
  }

__attribute__((pure)) constexpr inline bool is_empty() const& noexcept {
  return len() == 0u;
}

__attribute__((pure)) constexpr inline ::sus::num::usize len() const& noexcept {
  return len_;
}

__attribute__((pure)) constexpr inline const T* as_ptr() const& noexcept {
  return data_;
}

__attribute__((pure)) constexpr ::sus::ops::Range<const T*> as_ptr_range() const& noexcept {
 return ::sus::ops::Range<const T*>(as_ptr(), as_ptr() + len());
}

constexpr ::sus::result::Result<::sus::num::usize, ::sus::num::usize>
binary_search(const T& x) const& noexcept
 requires(::sus::cmp::Ord<T>)
{
 return binary_search_by([&x](const T& p) { return p <=> x; });
}

constexpr ::sus::result::Result<::sus::num::usize, ::sus::num::usize>
binary_search_by(
 ::sus::fn::FnMut<std::weak_ordering(const T&)> auto f) const& noexcept {
 using Result = ::sus::result::Result<::sus::num::usize, ::sus::num::usize>;

::sus::num::usize size = len();
 ::sus::num::usize left = 0u;
 ::sus::num::usize right = size;
 while (left < right) {
 auto mid = left + size / 2u;

auto cmp =
        ::sus::fn::call_mut(f, get_unchecked(::sus::marker::unsafe_fn, mid));

if (cmp == std::strong_ordering::less) {
      left = mid + 1u;
    } else if (cmp == std::strong_ordering::greater) {
      right = mid;
    } else {

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(mid.primitive_value < len_.primitive_value)

#pragma clang diagnostic pop
                                                                 ;
      return ::sus::ok(mid);
    }

size = right - left;
  }

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(left.primitive_value <= len_.primitive_value)

#pragma clang diagnostic pop
                                                               ;
  return ::sus::err(left);
}

template <::sus::cmp::StrongOrd Key>
::sus::result::
 Result<::sus::num::usize, ::sus::num::usize> constexpr binary_search_by_key(
 const Key& key,
 ::sus::fn::FnMut<Key(const T&)> auto f) const& noexcept {
 return binary_search_by([&key, &f](const T& p) -> std::strong_ordering {
 return ::sus::fn::call_mut(f, p) <=> key;
 });
}

constexpr Chunks<T> chunks(::sus::num::usize chunk_size) const& noexcept {
 return Chunks<T>(iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr ChunksExact<T> chunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return ChunksExact<T>::with_slice(iter_refs_.to_iter_from_view(), *this, chunk_size);
}

using ConcatOutputType = ::sus::collections::Vec<T>;

constexpr auto concat() const& noexcept
 requires(::sus::collections::Concat<T>)
{
 const auto length = len();
 ::sus::num::usize cap;
 for (::sus::num::usize i; i < length; i += 1u) {
 cap += get_unchecked(::sus::marker::unsafe_fn, i).len();
 }
 using Collection = typename T::ConcatOutputType;
 auto out = Collection::with_capacity(cap);
 for (::sus::num::usize i; i < length; i += 1u) {
 get_unchecked(::sus::marker::unsafe_fn, i).concat_into(out);
 }
 return out;
}

constexpr void concat_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

constexpr bool contains(const T& x) const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const auto length = len();
 const auto* const p = as_ptr();
 for (::sus::num::usize i; i < length; i += 1u) {
 if (*(p + i) == x) return true;
 }
 return false;
}

constexpr bool ends_with(const Slice<T>& suffix) const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const auto m = len();
 const auto n = suffix.len();
 return m >= n && suffix == (*this)[::sus::ops::RangeFrom(m - n)];
}

__attribute__((pure)) constexpr ::sus::Option<const T&> first() const& noexcept {
 if (len() > 0u) {
 return ::sus::Option<const T&>(get_unchecked(::sus::marker::unsafe_fn, 0u));
 } else {
 return ::sus::Option<const T&>();
 }
}

__attribute__((pure)) constexpr Option<const T&> get(::sus::num::usize i) const& noexcept {
 if (i < len()) [[likely]]
 return Option<const T&>(get_unchecked(::sus::marker::unsafe_fn, i));
 else
 return Option<const T&>();
}

__attribute__((pure)) constexpr inline const T& get_unchecked(
    ::sus::marker::UnsafeFnMarker, ::sus::num::usize i) const& noexcept {
                                                                ;
  return *(as_ptr() + i);
}

__attribute__((pure)) constexpr Option<Slice<T>> get_range(
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize length = len();
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(length);
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 if (rlen > length) return sus::none();

if (rstart > length || rstart > length - rlen) return sus::none();
 return Option<Slice<T>>(Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_view(), as_ptr() + rstart, rlen));
}

__attribute__((pure)) constexpr Slice<T> get_range_unchecked(
 ::sus::marker::UnsafeFnMarker,
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(len());
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_view(), as_ptr() + rstart, rlen);
}

__attribute__((pure)) constexpr SliceIter<const T&> iter() const& noexcept {
 return SliceIter<const T&>(iter_refs_.to_iter_from_view(), as_ptr(), len());
}

using JoinOutputType = ::sus::collections::Vec<T>;

template <class Sep>
constexpr auto join(const Sep& separator) const& noexcept
 requires(::sus::collections::Join<T, Sep>)
{
 const auto length = len();
 ::sus::num::usize cap;
 for (::sus::num::usize i; i < length; i += 1u) {
 cap += get_unchecked(::sus::marker::unsafe_fn, i).len();
 }
 using Collection = typename T::JoinOutputType;
 auto out = Collection::with_capacity(cap);
 if (length > 0u) get_unchecked(::sus::marker::unsafe_fn, 0u).join_into(out);
 for (::sus::num::usize i = 1u; i < length; i += 1u) {
 T::join_sep_into(out, separator);
 get_unchecked(::sus::marker::unsafe_fn, i).join_into(out);
 }
 return out;
}

constexpr void join_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

static constexpr void join_sep_into(::sus::collections::Vec<T>& vec,
 const Slice<T>& separator) noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(separator);
}

static constexpr void join_sep_into(::sus::collections::Vec<T>& vec,
 const T& separator) noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.push(::sus::clone(separator));
}

__attribute__((pure)) constexpr ::sus::Option<const T&> last() const& noexcept {
 const auto length = len();
 if (length > 0u)
 return ::sus::Option<const T&>(*(as_ptr() + length - 1u));
 else
 return ::sus::Option<const T&>();
}

constexpr ::sus::num::usize partition_point(
 ::sus::fn::FnMut<bool(const T&)> auto pred) const& noexcept {
 return binary_search_by([pred = ::sus::move(pred)](const T& x) {
 if (::sus::fn::call_mut(pred, x)) {
 return std::strong_ordering::less;
 } else {
 return std::strong_ordering::greater;
 }
 })
 .unwrap_or_else([](::sus::num::usize i) { return i; });
}

constexpr RChunks<T> rchunks(::sus::num::usize chunk_size) const& noexcept {
 return RChunks<T>(iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr RChunksExact<T> rchunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return RChunksExact<T>::with_slice(iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr ::sus::collections::Vec<T> repeat(usize n) const& noexcept
 requires(::sus::mem::TrivialCopy<T>)
{
 auto buf = ::sus::collections::Vec<T>();
 if (n == 0u) return buf;

const usize l = len();

const usize capacity = l.saturating_mul(n);
  buf.reserve(capacity);

buf.extend(iter());
  {
    usize m = n >> 1u;

while (m > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                      buf.as_mut_ptr() + buf.len(), buf.len());

const usize buf_len = buf.len();
      buf.set_len(::sus::marker::unsafe_fn, buf_len * 2u);
      m >>= 1u;
    }
  }

const usize rem_len = capacity - buf.len();
  if (rem_len > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                    buf.as_mut_ptr() + buf.len(), rem_len);

buf.set_len(::sus::marker::unsafe_fn, capacity);
  }
  return buf;
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplit<T, Pred> rsplit(Pred pred) const& noexcept {
 return RSplit<T, Pred>(
 Split<T, Pred>(iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitN<T, Pred> rsplitn(usize n, Pred pred) const& noexcept {
 return RSplitN<T, Pred>(
 RSplit<T, Pred>(
 Split<T, Pred>(iter_refs_.to_iter_from_view(), *this, ::sus::move(pred))),
 n);
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> split(Pred pred) const& noexcept {
 return Split<T, Pred>(iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at(
 ::sus::num::usize mid) const& noexcept {
 ::sus::check(mid <= len());
 return split_at_unchecked(::sus::marker::unsafe_fn, mid);
}

__attribute__((pure)) constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at_unchecked(
 ::sus::marker::UnsafeFnMarker, ::sus::num::usize mid) const& noexcept {

;

const ::sus::num::usize rem =
      len().unchecked_sub(::sus::marker::unsafe_fn, mid);

return ::sus::Tuple<Slice<T>, Slice<T>>(
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_view(), as_ptr(), mid),
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_view(), as_ptr() + mid, rem));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_first()
 const& noexcept {
 if (is_empty()) return ::sus::none();
 return ::sus::some(
 ::sus::tuple(*as_ptr(), (*this)[::sus::ops::RangeFrom<usize>(1u)]));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitInclusive<T, Pred> split_inclusive(Pred pred) const& noexcept {
 return SplitInclusive<T, Pred>(iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_last()
 const& noexcept {
 if (is_empty()) return ::sus::none();
 const usize last = len() - 1u;
 return ::sus::some(::sus::tuple(*(as_ptr() + last),
 (*this)[::sus::ops::RangeTo<usize>(last)]));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitN<T, Pred> splitn(usize n, Pred pred) const& noexcept {
 return SplitN<T, Pred>(
 Split<T, Pred>(iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)), n);
}

constexpr bool starts_with(const Slice<T>& needle) const&
 requires(::sus::cmp::Eq<T>)
{
 const auto n = needle.len();
 return len() >= n && needle == (*this)[::sus::ops::RangeTo(n)];
}

constexpr ::sus::Option<Slice<T>> strip_prefix(
 const Slice<T>& prefix) const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const usize n = prefix.len();
 if (n <= len()) {
 auto [head, tail] = split_at(n);
 if (head == prefix) {
 return ::sus::Option<Slice<T>>(tail);
 }
 }
 return ::sus::Option<Slice<T>>();
}

constexpr ::sus::Option<Slice<T>> strip_suffix(
 const Slice<T>& suffix) const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const auto l = len();
 const auto n = suffix.len();
 if (n <= l) {
 auto [head, tail] = split_at(l - n);
 if (tail == suffix) {
 return ::sus::Option<Slice<T>>(head);
 }
 }
 return ::sus::Option<Slice<T>>();
}

Vec<T> to_vec() const& noexcept
 requires(::sus::mem::Clone<T>);

__attribute__((pure)) constexpr Windows<T> windows(usize size) const& noexcept {
 ::sus::check(size > 0u);
 return Windows<T>(iter_refs_.to_iter_from_view(), *this, size);
}

private:
  constexpr Slice(::sus::iter::IterRefCounter refs, T* data [[clang::lifetimebound]],
                  usize len) noexcept
      : iter_refs_(::sus::move(refs)), data_(data), len_(len) {}

friend class SliceMut<T>;
 template <class VecT>
 friend class Vec;

[[no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
  T* data_;
  usize len_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(data_), decltype(len_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class T>
Vec<T> Slice<T>::to_vec() const& noexcept
 requires(::sus::mem::Clone<T>)
{
 auto v = Vec<T>::with_capacity(len_);
 for (::sus::usize i; i < len_; i += 1u) {
 v.push(::sus::clone(*(data_ + i)));
 }
 return v;
}

template <class T>
class [[clang::trivial_abi]] SliceMut final {
 public:
 static_assert(
 !std::is_reference_v<T>,
 "SliceMut holds references, so the type parameter can not also be "
 "a reference");
 static_assert(!std::is_const_v<T>,
 "SliceMut inner type should not be const, it provides mutable "
 "access to the slice. Use Slice to represent const access.");

constexpr SliceMut(::sus::marker::EmptyMarker) : SliceMut() {}

explicit constexpr SliceMut() = default;

__attribute__((pure)) static constexpr inline SliceMut from_raw_parts_mut(
 ::sus::marker::UnsafeFnMarker, T* data [[clang::lifetimebound]],
 usize len) noexcept {
 ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
 return SliceMut(::sus::iter::IterRefCounter::empty_for_view(), data, len);
 }

__attribute__((pure)) static constexpr inline SliceMut from_raw_collection_mut(
 ::sus::marker::UnsafeFnMarker, ::sus::iter::IterRefCounter refs,
 T* data [[clang::lifetimebound]], usize len) noexcept {
 ::sus::check(len <= ::sus::mog<usize>(isize::MAX));
 return SliceMut(::sus::move(refs), data, len);
 }

template <size_t N>
 requires(N <= ::sus::mog<usize>(isize::MAX_PRIMITIVE))
 __attribute__((pure)) static constexpr inline SliceMut from(
 T (&data)[N] [[clang::lifetimebound]]) {
 return SliceMut(::sus::iter::IterRefCounter::empty_for_view(), data, N);
 }

__attribute__((pure)) constexpr SliceIterMut<T&> into_iter() && noexcept {
 return SliceIterMut<T&>(

slice_.iter_refs_.to_iter_from_view(), slice_.data_, slice_.len_);
  }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const SliceMut<T>& l,
 const SliceMut& r) noexcept {
 return l.as_slice() == r.as_slice();
 }

template <class U>
 requires(!::sus::cmp::Eq<T, U>)
 friend constexpr inline bool operator==(const SliceMut<T>& l,
 const SliceMut& r) = delete;

__attribute__((pure)) constexpr inline T& operator[](usize i) const& noexcept {
 ::sus::check(i < len());
 return *(as_mut_ptr() + i);
 }

__attribute__((pure)) constexpr inline SliceMut<T> operator[](
 const ::sus::ops::RangeBounds<usize> auto range) const& noexcept {
 const usize length = len();
 const usize rstart = range.start_bound().unwrap_or(0u);
 const usize rend = range.end_bound().unwrap_or(length);
 const usize rlen = rend >= rstart ? rend - rstart : 0u;
 ::sus::check(rlen <= length);

::sus::check(rstart <= length && rstart <= length - rlen);
 return SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(),
 as_mut_ptr() + rstart, rlen);
 }

constexpr Slice<T> as_slice() const& noexcept { return *this; }

__attribute__((pure)) constexpr operator const Slice<T>&() const& noexcept {
 return slice_;
 }
 __attribute__((pure)) constexpr operator Slice<T>&() & noexcept { return slice_; }
 __attribute__((pure)) constexpr operator Slice<T>() && noexcept {
 return ::sus::move(slice_);
 }

void drop_iterator_invalidation_tracking(::sus::marker::UnsafeFnMarker) {
    slice_.iter_refs_ = ::sus::iter::IterRefCounter::empty_for_view();
  }

__attribute__((pure)) constexpr inline bool is_empty() const& noexcept {
  return len() == 0u;
}

__attribute__((pure)) constexpr inline ::sus::num::usize len() const& noexcept {
  return slice_.len_;
}

__attribute__((pure)) constexpr inline const T* as_ptr() const& noexcept {
  return slice_.data_;
}

__attribute__((pure)) constexpr ::sus::ops::Range<const T*> as_ptr_range() const& noexcept {
 return ::sus::ops::Range<const T*>(as_ptr(), as_ptr() + len());
}

::sus::num::usize size = len();
 ::sus::num::usize left = 0u;
 ::sus::num::usize right = size;
 while (left < right) {
 auto mid = left + size / 2u;

auto cmp =
        ::sus::fn::call_mut(f, get_unchecked(::sus::marker::unsafe_fn, mid));

if (cmp == std::strong_ordering::less) {
      left = mid + 1u;
    } else if (cmp == std::strong_ordering::greater) {
      right = mid;
    } else {

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(mid.primitive_value < slice_.len_.primitive_value)

#pragma clang diagnostic pop
                                                                 ;
      return ::sus::ok(mid);
    }

size = right - left;
  }

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(left.primitive_value <= slice_.len_.primitive_value)

#pragma clang diagnostic pop
                                                               ;
  return ::sus::err(left);
}

constexpr Chunks<T> chunks(::sus::num::usize chunk_size) const& noexcept {
 return Chunks<T>(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr ChunksExact<T> chunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return ChunksExact<T>::with_slice(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

using ConcatOutputType = ::sus::collections::Vec<T>;

constexpr void concat_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

if (rstart > length || rstart > length - rlen) return sus::none();
 return Option<Slice<T>>(Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), as_ptr() + rstart, rlen));
}

__attribute__((pure)) constexpr Slice<T> get_range_unchecked(
 ::sus::marker::UnsafeFnMarker,
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(len());
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), as_ptr() + rstart, rlen);
}

__attribute__((pure)) constexpr SliceIter<const T&> iter() const& noexcept {
 return SliceIter<const T&>(slice_.iter_refs_.to_iter_from_view(), as_ptr(), len());
}

using JoinOutputType = ::sus::collections::Vec<T>;

constexpr void join_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

constexpr RChunks<T> rchunks(::sus::num::usize chunk_size) const& noexcept {
 return RChunks<T>(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr RChunksExact<T> rchunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return RChunksExact<T>::with_slice(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr ::sus::collections::Vec<T> repeat(usize n) const& noexcept
 requires(::sus::mem::TrivialCopy<T>)
{
 auto buf = ::sus::collections::Vec<T>();
 if (n == 0u) return buf;

const usize l = len();

const usize capacity = l.saturating_mul(n);
  buf.reserve(capacity);

buf.extend(iter());
  {
    usize m = n >> 1u;

while (m > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                      buf.as_mut_ptr() + buf.len(), buf.len());

const usize buf_len = buf.len();
      buf.set_len(::sus::marker::unsafe_fn, buf_len * 2u);
      m >>= 1u;
    }
  }

const usize rem_len = capacity - buf.len();
  if (rem_len > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                    buf.as_mut_ptr() + buf.len(), rem_len);

buf.set_len(::sus::marker::unsafe_fn, capacity);
  }
  return buf;
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplit<T, Pred> rsplit(Pred pred) const& noexcept {
 return RSplit<T, Pred>(
 Split<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitN<T, Pred> rsplitn(usize n, Pred pred) const& noexcept {
 return RSplitN<T, Pred>(
 RSplit<T, Pred>(
 Split<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred))),
 n);
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> split(Pred pred) const& noexcept {
 return Split<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at_unchecked(
 ::sus::marker::UnsafeFnMarker, ::sus::num::usize mid) const& noexcept {

;

const ::sus::num::usize rem =
      len().unchecked_sub(::sus::marker::unsafe_fn, mid);

return ::sus::Tuple<Slice<T>, Slice<T>>(
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 slice_.iter_refs_.to_view_from_view(), as_ptr(), mid),
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 slice_.iter_refs_.to_view_from_view(), as_ptr() + mid, rem));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitInclusive<T, Pred> split_inclusive(Pred pred) const& noexcept {
 return SplitInclusive<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitN<T, Pred> splitn(usize n, Pred pred) const& noexcept {
 return SplitN<T, Pred>(
 Split<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)), n);
}

constexpr bool starts_with(const Slice<T>& needle) const&
 requires(::sus::cmp::Eq<T>)
{
 const auto n = needle.len();
 return len() >= n && needle == (*this)[::sus::ops::RangeTo(n)];
}

Vec<T> to_vec() const& noexcept
 requires(::sus::mem::Clone<T>);

__attribute__((pure)) constexpr Windows<T> windows(usize size) const& noexcept {
 ::sus::check(size > 0u);
 return Windows<T>(slice_.iter_refs_.to_iter_from_view(), *this, size);
}

__attribute__((pure)) constexpr inline T* as_mut_ptr() const& noexcept {
  return slice_.data_;
}

__attribute__((pure)) constexpr ::sus::ops::Range<T*> as_mut_ptr_range()
 const& noexcept {
 return ::sus::ops::Range<T*>(as_mut_ptr(), as_mut_ptr() + len());
}

constexpr ChunksExactMut<T> chunks_exact_mut(::sus::num::usize chunk_size)
 const& noexcept {
 return ChunksExactMut<T>::with_slice(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr ChunksMut<T> chunks_mut(::sus::num::usize chunk_size)
 const& noexcept {
 return ChunksMut<T>(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr void copy_from_slice(const Slice<T>& src) const& noexcept
 requires(::sus::mem::TrivialCopy<T>)
{
 const ::sus::num::usize src_len = src.len();
 const ::sus::num::usize dst_len = len();
 ::sus::check(dst_len == src_len);

const T* const src_ptr = src.as_ptr();
 T* const dst_ptr = as_mut_ptr();
 ::sus::check((src_ptr < dst_ptr && src_ptr <= dst_ptr - src_len) ||
 (dst_ptr < src_ptr && dst_ptr <= src_ptr - dst_len));

if (std::is_constant_evaluated()) {

for (::sus::num::usize i; i < dst_len; i += 1u)
 *(dst_ptr + i) = *(src_ptr + i);
 } else {
 if constexpr (::sus::mem::size_of<T>() > 1u) {
 constexpr auto max_len =
 ::sus::num::usize::MAX / ::sus::mem::size_of<T>();

if (dst_len > max_len) {
 for (::sus::num::usize i; i < dst_len; i += 1u)
 *(dst_ptr + i) = *(src_ptr + i);
 return;
 }
 }

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, src_ptr, dst_ptr,
                                    dst_len);
  }
}

constexpr void copy_from_slice_unchecked(
 ::sus::marker::UnsafeFnMarker, const Slice<T>& src) const& noexcept
 requires(std::is_trivially_copy_assignable_v<T>)
{
 const ::sus::num::usize dst_len = len();
 const T* const src_ptr = src.as_ptr();
 T* const dst_ptr = as_mut_ptr();

;

if (std::is_constant_evaluated()) {

for (::sus::num::usize i; i < dst_len; i += 1u)
 *(dst_ptr + i) = *(src_ptr + i);
 } else {
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, src_ptr, dst_ptr,
 dst_len);
 }
}

constexpr void clone_from_slice(const Slice<T>& src) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 const ::sus::num::usize src_len = src.len();
 const ::sus::num::usize dst_len = len();
 ::sus::check(dst_len == src_len);
 const T* const src_ptr = src.as_ptr();
 T* dst_ptr = as_mut_ptr();
 for (::sus::num::usize i; i < dst_len; i += 1u) {
 ::sus::clone_into(*(dst_ptr + i), *(src_ptr + i));
 }
}

constexpr void fill(T value) const& noexcept
 requires(::sus::mem::Clone<T>)
{

T* ptr = as_mut_ptr();
  T* const end_ptr = ptr + len();
  while (ptr != end_ptr) {
    ::sus::clone_into(*ptr, value);
    ptr += 1u;
  }
}

constexpr void fill_with(::sus::fn::FnMut<T()> auto f) const& noexcept {
 T* ptr = as_mut_ptr();
 T* const end_ptr = ptr + len();
 while (ptr != end_ptr) {
 *ptr = ::sus::fn::call_mut(f);
 ptr += 1u;
 }
}

constexpr void fill_with_default() const& noexcept
 requires(sus::construct::Default<T>)
{
 T* ptr = as_mut_ptr();
 T* const end_ptr = ptr + len();
 while (ptr != end_ptr) {
 *ptr = T();
 ptr += 1u;
 }
}

__attribute__((pure)) constexpr ::sus::Option<T&> first_mut() const& noexcept {
 if (len() > 0u)
 return ::sus::Option<T&>(*as_mut_ptr());
 else
 return ::sus::Option<T&>();
}

__attribute__((pure)) constexpr Option<T&> get_mut(::sus::num::usize i) const& noexcept {
 if (i < len()) [[likely]]
 return Option<T&>(get_unchecked_mut(::sus::marker::unsafe_fn, i));
 else
 return Option<T&>();
}

__attribute__((pure)) constexpr inline T& get_unchecked_mut(
    ::sus::marker::UnsafeFnMarker, ::sus::num::usize i) const& noexcept {
                                                                ;
  return *(as_mut_ptr() + i);
}

__attribute__((pure)) constexpr Option<SliceMut<T>> get_range_mut(
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize length = len();
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(length);
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 if (rlen > length) return sus::none();

if (rstart > length || rstart > length - rlen) return sus::none();
 return Option<SliceMut<T>>(SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), as_mut_ptr() + rstart,
 rlen));
}

__attribute__((pure)) constexpr SliceMut<T> get_range_mut_unchecked(
 ::sus::marker::UnsafeFnMarker,
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(len());
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 return SliceMut<T>::from_raw_collection_mut(::sus::marker::unsafe_fn,
 slice_.iter_refs_.to_view_from_view(),
 as_mut_ptr() + rstart, rlen);
}

__attribute__((pure)) constexpr SliceIterMut<T&> iter_mut() const& noexcept {
 return SliceIterMut<T&>(slice_.iter_refs_.to_iter_from_view(), as_mut_ptr(), len());
}

__attribute__((pure)) constexpr ::sus::Option<T&> last_mut() const& noexcept {
 const ::sus::num::usize length = len();
 if (length > 0u)
 return ::sus::Option<T&>(*(as_mut_ptr() + length - 1u));
 else
 return ::sus::Option<T&>();
}

constexpr RChunksExactMut<T> rchunks_exact_mut(::sus::num::usize chunk_size)
 const& noexcept {
 return RChunksExactMut<T>::with_slice(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr RChunksMut<T> rchunks_mut(::sus::num::usize chunk_size)
 const& noexcept {
 return RChunksMut<T>(slice_.iter_refs_.to_iter_from_view(), *this, chunk_size);
}

constexpr void reverse() const& noexcept
 requires(::sus::mem::Move<T>)
{
 const auto half_len = len() / 2u;
 const auto [start, end] = as_mut_ptr_range();

auto front_half = ::sus::collections::SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), start, half_len);

auto back_half = ::sus::collections::SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), end - half_len, half_len);

for (::sus::num::usize i; i < half_len; i += 1u) {

::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, front_half[i],
                                    back_half[half_len - 1u - i]);
  }
}

void rotate_left(::sus::num::usize mid) const& noexcept
 requires(::sus::mem::Move<T>)
{
 const ::sus::num::usize length = len();
 ::sus::check(mid <= length);
 const ::sus::num::usize k = length - mid;
 T* const p = as_mut_ptr();

if constexpr (::sus::mem::relocate_by_memcpy<T>) {
 if (!std::is_constant_evaluated()) {

}
  }

if (mid == 0u || k == 0u) return;

for (::sus::num::usize i; i < k; i += 1u) {
 ::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(p + i),
 *(p + mid + i));
 }
 if (k < mid) {

get_range_mut_unchecked(::sus::marker::unsafe_fn, ::sus::ops::RangeFrom(k))
        .rotate_left(mid - k);
  } else if (k > mid && mid % 2u != (k - mid) % 2u) {

if ((k - mid) % 2u == 1u) {

for (::sus::num::usize i = k; i < length - 1u; i += 1u) {
 ::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(p + i),
 *(p + length - 1u));
 }
 } else {

for (::sus::num::usize i = k; i < length - 1u; i += 1u) {
 ::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(p + i),
 *(p + i + 1u));
 }
 }
 }
}

void rotate_right(::sus::num::usize k) const& noexcept
 requires(::sus::mem::Move<T>)
{
 rotate_left(len() - k);
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitMut<T, Pred> rsplit_mut(Pred pred) const& noexcept {
 return RSplitMut<T, Pred>(
 SplitMut<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitNMut<T, Pred> rsplitn_mut(usize n,
 Pred pred) const& noexcept {
 return RSplitNMut<T, Pred>(
 RSplitMut<T, Pred>(
 SplitMut<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred))),
 n);
}

void sort() const& noexcept
 requires(::sus::cmp::Ord<T>)
{
 if (len() > ::sus::num::usize(0u)) {
 std::stable_sort(as_mut_ptr(), as_mut_ptr() + len());
 }
}

void sort_by(::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto
 compare) const& noexcept {
 if (len() > ::sus::num::usize(0u)) {
 std::stable_sort(as_mut_ptr(), as_mut_ptr() + len(),
 [&compare](const T& l, const T& r) {
 return ::sus::fn::call_mut(compare, l, r) < 0;
 });
 }
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_by_key(KeyFn f) const& noexcept {
 return sort_by([&f](const T& a, const T& b) {
 return ::sus::fn::call_mut(f, a) <=> ::sus::fn::call_mut(f, b);
 });
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_by_cached_key(KeyFn f) const& noexcept {
 constexpr auto sz_u8 = ::sus::mem::size_of<::sus::Tuple<Key, u8>>();
 constexpr auto sz_u16 = ::sus::mem::size_of<::sus::Tuple<Key, u16>>();
 constexpr auto sz_u32 = ::sus::mem::size_of<::sus::Tuple<Key, u32>>();
 constexpr auto sz_usize = ::sus::mem::size_of<::sus::Tuple<Key, usize>>();

const auto length = len();
 if (length < 2u) {
 return;
 }
 if constexpr (sz_u8 < sz_u16) {
 if (length <= u8::MAX) {
 __private::sort_slice_by_cached_key<u8, Key, T>(*this, f);
 return;
 }
 }
 if constexpr (sz_u16 < sz_u32) {
 if (length <= u16::MAX) {
 __private::sort_slice_by_cached_key<u16, Key, T>(*this, f);
 return;
 }
 }
 if constexpr (sz_u32 < sz_usize) {
 if (length <= u32::MAX) {
 __private::sort_slice_by_cached_key<u32, Key, T>(*this, f);
 return;
 }
 }
 __private::sort_slice_by_cached_key<usize, Key, T>(*this, f);
}

constexpr void sort_unstable() const& noexcept
 requires(::sus::cmp::Ord<T>)
{
 if (len() > 0u) {
 std::sort(as_mut_ptr(), as_mut_ptr() + len());
 }
}

constexpr void sort_unstable_by(
 ::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto compare)
 const& noexcept {
 if (len() > 0u) {
 std::sort(as_mut_ptr(), as_mut_ptr() + len(),
 [&compare](const T& l, const T& r) {
 return ::sus::fn::call_mut(compare, l, r) < 0;
 });
 }
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_unstable_by_key(KeyFn f) const& noexcept {
 return sort_unstable_by([&f](const T& a, const T& b) {
 return ::sus::fn::call_mut(f, a) <=> ::sus::fn::call_mut(f, b);
 });
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitMut<T, Pred> split_mut(Pred pred) const& noexcept {
 return SplitMut<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Tuple<SliceMut<T>, SliceMut<T>> split_at_mut(
 ::sus::num::usize mid) const& noexcept {
 ::sus::check(mid <= len());
 return split_at_mut_unchecked(::sus::marker::unsafe_fn, mid);
}

__attribute__((pure)) constexpr ::sus::Tuple<SliceMut<T>, SliceMut<T>>
split_at_mut_unchecked(::sus::marker::UnsafeFnMarker,
 ::sus::num::usize mid) const& noexcept {

;

const ::sus::num::usize rem =
      len().unchecked_sub(::sus::marker::unsafe_fn, mid);

return ::sus::Tuple<SliceMut<T>, SliceMut<T>>(
 SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, slice_.iter_refs_.to_view_from_view(), as_mut_ptr(), mid),
 SliceMut<T>::from_raw_collection_mut(::sus::marker::unsafe_fn,
 slice_.iter_refs_.to_view_from_view(),
 as_mut_ptr() + mid, rem));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<T&, SliceMut<T>>>
split_first_mut() const& noexcept {
 if (is_empty()) return ::sus::none();
 return ::sus::some(
 ::sus::tuple(*as_mut_ptr(),

get_range_mut_unchecked(::sus::marker::unsafe_fn,
 ::sus::ops::RangeFrom<usize>(1u))));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitInclusiveMut<T, Pred> split_inclusive_mut(Pred pred)
 const& noexcept {
 return SplitInclusiveMut<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<T&, SliceMut<T>>> split_last_mut()
 const& noexcept {
 if (is_empty()) return ::sus::none();
 const usize last = len() - 1u;
 return ::sus::some(
 ::sus::tuple(*(as_mut_ptr() + last),

get_range_mut_unchecked(::sus::marker::unsafe_fn,
 ::sus::ops::RangeTo<usize>(last))));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitNMut<T, Pred> splitn_mut(usize n,
 Pred pred) const& noexcept {
 return SplitNMut<T, Pred>(
 SplitMut<T, Pred>(slice_.iter_refs_.to_iter_from_view(), *this, ::sus::move(pred)), n);
}

constexpr ::sus::Option<SliceMut<T>> strip_prefix_mut(const Slice<T>& prefix)
 const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const usize n = prefix.len();
 if (n <= len()) {
 auto [head, tail] = split_at_mut(n);
 if (head == prefix) {
 return ::sus::Option<SliceMut<T>>(tail);
 }
 }
 return ::sus::Option<SliceMut<T>>();
}

constexpr ::sus::Option<SliceMut<T>> strip_suffix_mut(const Slice<T>& suffix)
 const& noexcept
 requires(::sus::cmp::Eq<T>)
{
 const auto l = len();
 const auto n = suffix.len();
 if (n <= l) {
 auto [head, tail] = split_at_mut(l - n);
 if (tail == suffix) {
 return ::sus::Option<SliceMut<T>>(head);
 }
 }
 return ::sus::Option<SliceMut<T>>();
}

constexpr void swap(usize a, usize b) const& noexcept {
 ::sus::check(a < len() && b < len());

::sus::mem::swap(*(as_mut_ptr() + a), *(as_mut_ptr() + b));
}

constexpr void swap_nonoverlapping(::sus::marker::UnsafeFnMarker, usize a,
                                   usize b) const& noexcept {
                                                         ;
                                                                ;
                                                                ;

::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(as_mut_ptr() + a),
                                  *(as_mut_ptr() + b));
}

constexpr void swap_unchecked(::sus::marker::UnsafeFnMarker, usize a,
                              usize b) const& noexcept {
                                                                ;
                                                                ;
  ::sus::mem::swap(*(as_mut_ptr() + a), *(as_mut_ptr() + b));
}

constexpr void swap_with_slice(const SliceMut<T>& other)
 const& noexcept {
 auto const self_len = len();
 auto const other_len = other.len();
 T* const self_ptr = as_mut_ptr();
 T* const other_ptr = other.as_mut_ptr();

::sus::check(self_len == other_len);
 if (other_ptr <= self_ptr) {
 ::sus::check(other_ptr + other_len <= self_ptr);
 } else {
 ::sus::check(self_ptr + self_len <= other_ptr);
 }

::sus::ptr::swap_nonoverlapping(::sus::marker::unsafe_fn, self_ptr, other_ptr,
                                  self_len);
}

__attribute__((pure)) constexpr WindowsMut<T> windows_mut(usize size) const& noexcept {
 ::sus::check(size > 0u);
 return WindowsMut<T>(slice_.iter_refs_.to_iter_from_view(), *this, size);
}

private:
  constexpr SliceMut(sus::iter::IterRefCounter refs, T* data, usize len)
      : slice_(::sus::move(refs), data, len) {}

template <class VecT>
 friend class Vec;

Slice<T> slice_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(slice_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

template <class T>
Vec<T> SliceMut<T>::to_vec() const& noexcept
 requires(::sus::mem::Clone<T>)
{
 auto v = Vec<T>::with_capacity(slice_.len_);
 for (::sus::usize i; i < slice_.len_; i += 1u) {
 v.push(::sus::clone(*(slice_.data_ + i)));
 }
 return v;
}

using ::sus::iter::begin;

using ::sus::iter::end;

}

template <class T, class Char>
struct fmt::formatter<::sus::collections::Slice<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::collections::Slice<T>& slice,
 FormatContext& ctx) const {
 auto out = ctx.out();
 out = fmt::format_to(out, "[");
 for (::sus::num::usize i; i < slice.len(); i += 1u) {
 if (i > 0u) out = fmt::format_to(out, ", ");
 ctx.advance_to(out);
 out = underlying_.format(slice[i], ctx);
 }
 return fmt::format_to(out, "]");
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::collections { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const Slice <T>& value ) { static_assert(fmt::is_formattable<Slice <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

template <class T, class Char>
struct fmt::formatter<::sus::collections::SliceMut<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::collections::SliceMut<T>& slice,
 FormatContext& ctx) const {
 auto out = ctx.out();
 out = fmt::format_to(out, "[");
 for (::sus::num::usize i; i < slice.len(); i += 1u) {
 if (i > 0u) out = fmt::format_to(out, ", ");
 ctx.advance_to(out);
 out = underlying_.format(slice[i], ctx);
 }
 return fmt::format_to(out, "]");
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::collections { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const SliceMut <T>& value ) { static_assert(fmt::is_formattable<SliceMut <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus {
using ::sus::collections::Slice;
using ::sus::collections::SliceMut;
}

namespace sus::collections {

namespace __private {

template <class T, size_t N>
struct Storage final {
 [[no_unique_address]] sus::iter::IterRefCounter iter_refs_;

T data_[N];
};

template <class T>
struct Storage<T, 0> final {};

}

template <class T, size_t N>
class Array final {
 static_assert(N <= ::sus::mog<usize>(isize::MAX));
 static_assert(!std::is_reference_v<T>,
 "Array<T&, N> is invalid as Array must hold value types. Use "
 "Array<T*, N> instead.");
 static_assert(!std::is_const_v<T>,
 "`Array<const T, N>` should be written `const Array<T, N>`, as "
 "const applies transitively.");

public:

explicit constexpr Array() noexcept
 requires(::sus::construct::Default<T>)
 : Array(WITH_DEFAULT, std::make_index_sequence<N>()) {}

template <std::convertible_to<T>... Ts>
 requires(sizeof...(Ts) == N &&
 N > 0u)
 explicit constexpr Array(Ts&&... ts) noexcept
 : storage_(::sus::iter::IterRefCounter::for_owner(),
 {::sus::forward<Ts>(ts)...}) {}

template <std::convertible_to<T> U>
 requires(::sus::mem::Copy<T>)
 constexpr static Array with_value(const U& t) noexcept {
 return [&t]<size_t... Is>(std::index_sequence<Is...>) {
 return Array(((void)Is, t)...);
 }(std::make_index_sequence<N>());
 }

constexpr static Array with_initializer(
 ::sus::fn::FnMut<T()> auto f) noexcept {
 if constexpr (N == 0u)
 return Array();
 else
 return Array(WITH_INITIALIZER, std::make_index_sequence<N>(), f);
 }

Array(Array&&)
 requires(N == 0 && ::sus::mem::Move<T>)
 = default;
 Array& operator=(Array&&)
 requires(N == 0 && ::sus::mem::Move<T>)
 = default;

constexpr Array(Array&& o) noexcept
 requires(N > 0 && ::sus::mem::Move<T>)
 : Array(WITH_MOVE_FROM_POINTER, o.storage_.data_,
 o.storage_.iter_refs_.take_for_owner(),
 std::make_index_sequence<N>()) {
 ::sus::check(!has_iterators());
 }
 constexpr Array& operator=(Array&& o) noexcept
 requires(::sus::mem::Move<T>)
 {
 ::sus::check(!has_iterators());
 ::sus::check(!o.has_iterators());
 for (usize i; i < N; i += 1u)
 *(storage_.data_ + i) = ::sus::mem::take(*(o.storage_.data_ + i));
 storage_.iter_refs_ = o.storage_.iter_refs_.take_for_owner();
 return *this;
 }

Array(Array&&)
 requires(!::sus::mem::Move<T>)
 = delete;
 Array& operator=(Array&&)
 requires(!::sus::mem::Move<T>)
 = delete;

constexpr Array clone() const& noexcept
 requires(::sus::mem::Clone<T>)
 {
 if constexpr (N == 0) {
 return Array();
 } else {
 return Array(WITH_CLONE_FROM_POINTER, storage_.data_,
 std::make_index_sequence<N>());
 }
 }

constexpr void clone_from(const Array& source) & noexcept
 requires(::sus::mem::Clone<T>)
 {
 if constexpr (N > 0) {
 if (&source == this) [[unlikely]]
 return;
 for (usize i; i < N; i += 1u) {
 ::sus::clone_into(get_unchecked_mut(::sus::marker::unsafe_fn, i),
 source.get_unchecked(::sus::marker::unsafe_fn, i));
 }
 }
 }

~Array()
 requires(std::is_trivially_destructible_v<T>)
 = default;
 constexpr ~Array()
 requires(!std::is_trivially_destructible_v<T>)
 {
 for (usize i; i < N; i += 1u) (storage_.data_ + i)->~T();
 }

constexpr usize len() const& noexcept { return N; }

constexpr Option<const T&> get(usize i) const& noexcept [[clang::lifetimebound]]
 requires(N > 0)
 {
 if (i >= N) [[unlikely]]
 return Option<const T&>();
 return Option<const T&>(*(storage_.data_ + i));
 }
 constexpr Option<const T&> get(usize i) && = delete;

constexpr Option<T&> get_mut(usize i) & noexcept [[clang::lifetimebound]]
 requires(N > 0)
 {
 if (i >= N) [[unlikely]]
 return Option<T&>();
 return Option<T&>(*(storage_.data_ + i));
 }

constexpr inline const T& get_unchecked(
      ::sus::marker::UnsafeFnMarker, usize i) const& noexcept [[clang::lifetimebound]]
    requires(N > 0)
  {
    return *(storage_.data_ + i);
  }
  constexpr inline const T& get_unchecked(::sus::marker::UnsafeFnMarker,
                                          usize i) && = delete;

constexpr inline T& get_unchecked_mut(::sus::marker::UnsafeFnMarker,
                                        usize i) & noexcept [[clang::lifetimebound]]
    requires(N > 0)
  {
    return *(storage_.data_ + i);
  }

constexpr inline const T& operator[](usize i) const& noexcept
 [[clang::lifetimebound]] {
 check(i < N);
 return *(storage_.data_ + i);
 }
 constexpr inline const T& operator[](usize i) && = delete;

constexpr inline T& operator[](usize i) & noexcept [[clang::lifetimebound]] {
 check(i < N);
 return *(storage_.data_ + i);
 }

constexpr inline const T* as_ptr() const& noexcept [[clang::lifetimebound]]
    requires(N > 0)
  {
    return storage_.data_;
  }
  const T* as_ptr() && = delete;

constexpr inline T* as_mut_ptr() & noexcept [[clang::lifetimebound]]
    requires(N > 0)
  {
    return storage_.data_;
  }

constexpr Slice<T> as_slice() const& noexcept [[clang::lifetimebound]] {
 return Slice<T>::from(storage_.data_);
 }
 constexpr Slice<T> as_slice() && = delete;

constexpr SliceMut<T> as_mut_slice() & noexcept [[clang::lifetimebound]] {
 return SliceMut<T>::from(storage_.data_);
 }

constexpr SliceIter<const T&> iter() const& noexcept [[clang::lifetimebound]] {
 if constexpr (N == 0) {
 return SliceIter<const T&>(
 sus::iter::IterRefCounter::empty_for_view().to_iter_from_view(),
 nullptr, N);
 } else {

return SliceIter<const T&>(storage_.iter_refs_.to_iter_from_owner(),
 storage_.data_, N);
 }
 }
 constexpr SliceIter<const T&> iter() && = delete;

constexpr SliceIterMut<T&> iter_mut() & noexcept [[clang::lifetimebound]] {
 if constexpr (N == 0) {
 return SliceIterMut<T&>(
 sus::iter::IterRefCounter::empty_for_view().to_iter_from_view(),
 nullptr, N);
 } else {
 return SliceIterMut<T&>(storage_.iter_refs_.to_iter_from_owner(),
 storage_.data_, N);
 }
 }

template <int&..., class U = T>
 constexpr ArrayIntoIter<U, N> into_iter() && noexcept
 requires(::sus::mem::Move<T>)
 {
 return ArrayIntoIter<T, N>(::sus::move(*this));
 }

template <::sus::fn::FnMut<::sus::fn::NonVoid(T&&)> MapFn>
 requires(N > 0)
 Array<sus::fn::ReturnOnce<MapFn, T&&>, N> map(MapFn f) && noexcept {
 return Array<sus::fn::ReturnOnce<MapFn, T&&>, N>::with_initializer(
 [this, &f, i = 0_usize]() mutable {
 return f(
 ::sus::move(*(storage_.data_ + ::sus::mem::replace(i, i + 1u))));
 });
 }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 constexpr bool operator==(const Array<U, N>& r) const& noexcept
 requires(::sus::cmp::Eq<T>)
 {
 return eq_impl(r, std::make_index_sequence<N>());
 }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Array<T, N>& l,
 const Slice& r) noexcept {
 return r.len() == N && l.eq_impl(r, std::make_index_sequence<N>());
 }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Array<T, N>& l,
 const SliceMut& r) noexcept {
 return r.len() == N && l.eq_impl(r, std::make_index_sequence<N>());
 }

__attribute__((pure)) constexpr operator Slice<T>() const& noexcept
 requires(N == 0u)
 {
 return Slice<T>();
 }
 __attribute__((pure)) constexpr operator Slice<T>() const& noexcept
 requires(N > 0u)
 {
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn,

sus::iter::IterRefCounter::empty_for_view(), storage_.data_, N);
 }
 __attribute__((pure)) constexpr operator Slice<T>() && = delete;
 __attribute__((pure)) constexpr operator Slice<T>() & noexcept
 requires(N == 0u)
 {
 return Slice<T>();
 }
 __attribute__((pure)) constexpr operator Slice<T>() & noexcept
 requires(N > 0u)
 {
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn,

sus::iter::IterRefCounter::empty_for_view(), storage_.data_, N);
  }

__attribute__((pure)) constexpr operator SliceMut<T>() & noexcept
 requires(N == 0u)
 {
 return SliceMut<T>();
 }
 __attribute__((pure)) constexpr operator SliceMut<T>() & noexcept
 requires(N > 0u)
 {
 return SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn,

sus::iter::IterRefCounter::empty_for_view(), storage_.data_, N);
  }

private:
 enum WithDefault { WITH_DEFAULT };
 template <size_t... Is>
 requires(N == 0u)
 constexpr Array(WithDefault, std::index_sequence<Is...>) noexcept {}
 template <size_t... Is>
 requires(N > 0u)
 constexpr Array(WithDefault, std::index_sequence<Is...>) noexcept
 : storage_(::sus::iter::IterRefCounter::for_owner(),
 {((void)Is, T())...}) {}

enum WithInitializer { WITH_INITIALIZER };
 template <size_t... Is>
 requires(N > 0u)
 constexpr Array(WithInitializer, std::index_sequence<Is...>,
 ::sus::fn::FnMut<T()> auto& f) noexcept
 : storage_(::sus::iter::IterRefCounter::for_owner(),

{((void)Is, ::sus::fn::call_mut(f))...}) {}

enum WithMoveFromPointer { WITH_MOVE_FROM_POINTER };
 template <size_t... Is>
 requires(N > 0u)
 constexpr Array(WithMoveFromPointer, T* t, ::sus::iter::IterRefCounter refs,
 std::index_sequence<Is...>) noexcept
 : storage_(::sus::move(refs), {::sus::move(*(t + Is))...}) {}

enum WithCloneFromPointer { WITH_CLONE_FROM_POINTER };
 template <size_t... Is>
 requires(N > 0u)
 constexpr Array(WithCloneFromPointer, const T* t,
 std::index_sequence<Is...>) noexcept
 : storage_(::sus::iter::IterRefCounter::for_owner(),
 {::sus::clone(*(t + Is))...}) {}

constexpr inline bool has_iterators() const noexcept
    requires(N > 0u)
  {
    return storage_.iter_refs_.count_from_owner() != 0u;
  }

template <size_t... Is>
 constexpr inline auto eq_impl(const auto& r,
 std::index_sequence<Is...>) const& noexcept {
 return (... && (get_unchecked(::sus::marker::unsafe_fn, Is) ==
 r.get_unchecked(::sus::marker::unsafe_fn, Is)));
 };

::sus::collections::__private::Storage<T, N> storage_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert( std::is_same_v<std::remove_cv_t<decltype((N == 0 || ::sus::mem::relocate_by_memcpy<T>))>, bool>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = (N == 0 || ::sus::mem::relocate_by_memcpy<T>);

};

template <class T, class... Ts>
 requires((... &&
 std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<Ts>>))
Array(T&&, Ts&&...) -> Array<std::remove_cvref_t<T>, 1u + sizeof...(Ts)>;

namespace __private {

template <size_t I>
constexpr inline bool array_cmp_impl(sus::cmp::Ordering auto& val,
 const auto& l, const auto& r) noexcept {
 auto cmp = l.get_unchecked(::sus::marker::unsafe_fn, I) <=>
 r.get_unchecked(::sus::marker::unsafe_fn, I);

if (cmp != 0) val = cmp;

return val == 0;
};

template <size_t... Is>
constexpr inline auto array_cmp(sus::cmp::Ordering auto equal, const auto& l,
 const auto& r,
 std::index_sequence<Is...>) noexcept {
 auto val = equal;
 (true && ... && (array_cmp_impl<Is>(val, l, r)));
 return val;
};

}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveStrongOrd<T, U>)
constexpr inline std::strong_ordering operator<=>(
 const Array<T, N>& l, const Array<U, N>& r) noexcept {
 return __private::array_cmp(std::strong_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveOrd<T, U>)
constexpr inline std::weak_ordering operator<=>(const Array<T, N>& l,
 const Array<U, N>& r) noexcept {
 return __private::array_cmp(std::weak_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusivePartialOrd<T, U>)
constexpr inline std::partial_ordering operator<=>(
 const Array<T, N>& l, const Array<U, N>& r) noexcept {
 return __private::array_cmp(std::partial_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveStrongOrd<T, U>)
constexpr inline std::strong_ordering operator<=>(const Array<T, N>& l,
 const Slice& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::strong_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveOrd<T, U>)
constexpr inline std::weak_ordering operator<=>(const Array<T, N>& l,
 const Slice& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::weak_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusivePartialOrd<T, U>)
constexpr inline std::partial_ordering operator<=>(const Array<T, N>& l,
 const Slice& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::partial_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveStrongOrd<T, U>)
constexpr inline std::strong_ordering operator<=>(
 const Array<T, N>& l, const SliceMut& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::strong_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusiveOrd<T, U>)
constexpr inline std::weak_ordering operator<=>(const Array<T, N>& l,
 const SliceMut& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::weak_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <class T, class U, size_t N>
 requires(::sus::cmp::ExclusivePartialOrd<T, U>)
constexpr inline std::partial_ordering operator<=>(
 const Array<T, N>& l, const SliceMut& r) noexcept {
 if (r.len() != N) return r.len() <=> N;
 return __private::array_cmp(std::partial_ordering::equivalent, l, r,
 std::make_index_sequence<N>());
}

template <size_t I, class T, size_t N>
const auto& get(const Array<T, N>& a) noexcept {
 return a.get_unchecked(::sus::marker::unsafe_fn, I);
}

template <size_t I, class T, size_t N>
auto& get(Array<T, N>& a) noexcept {
 return a.get_unchecked_mut(::sus::marker::unsafe_fn, I);
}

template <size_t I, class T, size_t N>
auto get(Array<T, N>&& a) noexcept {
 return ::sus::move(a.get_unchecked_mut(::sus::marker::unsafe_fn, I));
}

}

namespace std {
template <class T, size_t N>
struct tuple_size<::sus::collections::Array<T, N>> {
 static constexpr size_t value = N;
};

template <size_t I, class T, size_t N>
struct tuple_element<I, ::sus::collections::Array<T, N>> {
 using type = T;
};
}

template <class T, size_t N, class Char>
struct fmt::formatter<::sus::collections::Array<T, N>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::collections::Array<T, N>& array,
 FormatContext& ctx) const
 requires(N > 0)
 {
 auto out = ctx.out();
 out = fmt::format_to(out, "[");
 for (::sus::num::usize i; i < array.len(); i += 1u) {
 if (i > 0u) out = fmt::format_to(out, ", ");
 ctx.advance_to(out);
 out = underlying_.format(array[i], ctx);
 }
 return fmt::format_to(out, "]");
 }

template <class FormatContext>
 constexpr auto format(const ::sus::collections::Array<T, N>&,
 FormatContext& ctx) const
 requires(N == 0)
 {
 return fmt::format_to(ctx.out(), "[]");
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::collections {
template <class T, size_t N,
 ::sus::string::__private::StreamCanReceiveString<char> StreamType>
inline StreamType& operator<<(StreamType& stream, const Array<T, N>& value) {
 return ::sus::string::__private::format_to_stream(stream,
 fmt::to_string(value));
}

}

namespace sus::collections {

using ::sus::iter::begin;

using ::sus::iter::end;
}

namespace sus {
using ::sus::collections::Array;
}

namespace sus::collections {

template <class ItemT>
struct [[nodiscard]] Drain final
 : public ::sus::iter::IteratorBase<Drain<ItemT>, ItemT> {
 public:
 using Item = ItemT;

public:
  constexpr Drain(Drain&& rhs) noexcept
      : tail_start_(rhs.tail_start_),
        tail_len_(rhs.tail_len_),
        original_vec_(::sus::move(rhs.original_vec_)),
        vec_(::sus::move(rhs.vec_)),

iter_(rhs.iter_.take()) {}

constexpr Drain& operator=(Drain&&) noexcept { ::sus::panic(); }

~Drain() noexcept {

if (iter_.is_some()) {
      restore_vec(0u);
    }
  }

void keep_rest() && noexcept {
    const usize unyielded_len = iter_->exact_size_hint();
    Item* const unyielded_ptr =
        iter_.take().unwrap().as_mut_slice().as_mut_ptr();

const usize start = vec_.len();
    Item* const start_ptr = vec_.as_mut_ptr() + start;

if (unyielded_ptr != start_ptr) {
      Item* const src = unyielded_ptr;
      Item* const dst = start_ptr;

if constexpr (::sus::mem::relocate_by_memcpy<Item>) {

if (unyielded_len > 0u) {
 ::sus::ptr::copy(::sus::marker::unsafe_fn, src, dst, unyielded_len);
 }
 } else {
 for (usize i; i < unyielded_len; i += 1u) {
 *(dst + i) = ::sus::move(*(src + i));
 }
 }
 }

restore_vec(unyielded_len);
  }

Option<Item> next() noexcept {

return iter_->next().map([](Item& i) { return sus::move(i); });
  }

Option<Item> next_back() noexcept {

return iter_->next_back().map([](Item& i) { return sus::move(i); });
  }

::sus::iter::SizeHint size_hint() const noexcept {
    return iter_->size_hint();
  }

::sus::num::usize exact_size_hint() const noexcept {
    return iter_->exact_size_hint();
  }

private:

template <class VecT>
 friend class Vec;

void restore_vec(usize kept) {
    const usize start = vec_.len() + kept;
    const usize tail = tail_start_;
    if (start != tail) {

const usize drop_len = tail - start;
      Item* const src = vec_.as_mut_ptr() + tail;
      Item* const dst = vec_.as_mut_ptr() + start;

if constexpr (::sus::mem::relocate_by_memcpy<Item>) {

if (tail_len_ > 0u) {
 ::sus::ptr::copy(::sus::marker::unsafe_fn, src, dst, tail_len_);
 }
 } else {
 usize i;
 for (; i < tail_len_; i += 1u) {
 *(dst + i) = ::sus::move(*(src + i));
 }
 for (; i < tail_len_ + drop_len; i += 1u) {
 (dst + i)->~Item();
 }
 }
 }
 vec_.set_len(::sus::marker::unsafe_fn, start + tail_len_);
 original_vec_.as_mut() = ::sus::move(vec_);
 }

explicit constexpr Drain(Vec<Item>&& vec [[clang::lifetimebound]],
 ::sus::ops::Range<usize> range) noexcept
 : tail_start_(range.finish),
 tail_len_(vec.len() - range.finish),
 vec_(::sus::move(vec)),

original_vec_(vec) {

auto slice = vec_.get_range_mut(range).unwrap();

slice.drop_iterator_invalidation_tracking(::sus::marker::unsafe_fn);
    iter_ = ::sus::some(::sus::move(slice).iter_mut());

vec_.set_len(::sus::marker::unsafe_fn, range.start);
  }

usize tail_start_;

usize tail_len_;

sus::ptr::NonNull<Vec<Item>> original_vec_;

Vec<Item> vec_;

Option<SliceIterMut<Item&>> iter_;

};
}

namespace sus::collections {

template <class ItemT>
struct [[nodiscard]] VecIntoIter final
 : public ::sus::iter::IteratorBase<VecIntoIter<ItemT>, ItemT> {
 public:
 using Item = ItemT;

constexpr VecIntoIter(Vec<Item>&& vec) noexcept : vec_(::sus::move(vec)) {}

constexpr VecIntoIter clone() const noexcept
 requires(::sus::mem::Clone<Item>)
 {
 return VecIntoIter(::sus::clone(vec_), front_index_, back_index_);
 }

constexpr Option<Item> next() noexcept {
 if (front_index_ == back_index_) [[unlikely]]
 return Option<Item>();

Item& item = vec_.get_unchecked_mut(
 ::sus::marker::unsafe_fn,
 ::sus::mem::replace(front_index_, front_index_ + 1_usize));
 return Option<Item>(move(item));
 }

constexpr Option<Item> next_back() noexcept {
 if (front_index_ == back_index_) [[unlikely]]
 return Option<Item>();

back_index_ -= 1u;
 Item& item = vec_.get_unchecked_mut(::sus::marker::unsafe_fn, back_index_);
 return Option<Item>(move(item));
 }

constexpr ::sus::iter::SizeHint size_hint() const noexcept {
 const usize remaining = back_index_ - front_index_;
 return ::sus::iter::SizeHint(remaining,
 ::sus::Option<::sus::num::usize>(remaining));
 }

constexpr ::sus::num::usize exact_size_hint() const noexcept {
    return back_index_ - front_index_;
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
      const noexcept {
    return {};
  }

private:

constexpr VecIntoIter(Vec<Item>&& vec, usize front, usize back) noexcept
 : vec_(::sus::move(vec)), front_index_(front), back_index_(back) {}

Vec<Item> vec_;
 usize front_index_ = 0_usize;
 usize back_index_ = vec_.len();

};

}

namespace sus::iter {

template <class RefIterator>
class [[nodiscard]] [[clang::trivial_abi]] ByRef final
 : public IteratorBase<ByRef<RefIterator>, typename RefIterator::Item> {
 public:
 using Item = RefIterator::Item;

ByRef(ByRef&&) = default;
  ByRef& operator=(ByRef&&) = default;

constexpr ByRef clone() const noexcept { return ByRef(next_iter_); }

constexpr Option<Item> next() noexcept { return next_iter_->next(); }

constexpr SizeHint size_hint() const noexcept {
    return next_iter_->size_hint();
  }

constexpr Option<Item> next_back() noexcept
 requires(DoubleEndedIterator<RefIterator, Item>)
 {
 return next_iter_->next_back();
 }

constexpr usize exact_size_hint() const noexcept
 requires(ExactSizeIterator<RefIterator, Item>)
 {
 return next_iter_->exact_size_hint();
 }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
 const noexcept
 requires(TrustedLen<RefIterator>)
 {
 return {};
 }

constexpr ~ByRef() noexcept {

}

private:
 template <class U, class V>
 friend class IteratorBase;

explicit constexpr ByRef(RefIterator& next_iter [[clang::lifetimebound]]) noexcept
      : next_iter_(::sus::mem::addressof(next_iter)) {

}

RefIterator* _Nonnull next_iter_;

static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); static_assert(std::is_same_v<decltype(::sus::marker::unsafe_fn), const ::sus::marker::UnsafeFnMarker>); template <class SusOuterClassTypeForTriviallyReloc> friend struct ::sus::mem::__private::relocatable_tag; static constexpr bool SusUnsafeTrivialRelocate = ::sus::mem::relocate_by_memcpy<decltype(next_iter_)>; static_assert(SusUnsafeTrivialRelocate, "Type is not trivially relocatable");

};

}

namespace sus::iter {

template <class InnerSizedIter>
class [[nodiscard]] Enumerate final
 : public IteratorBase<Enumerate<InnerSizedIter>,
 ::sus::Tuple<usize, typename InnerSizedIter::Item>> {
 using FromItem = typename InnerSizedIter::Item;

public:
 using Item = ::sus::Tuple<usize, FromItem>;

Enumerate(Enumerate&&) = default;
  Enumerate& operator=(Enumerate&&) = default;

constexpr Enumerate clone() const noexcept
 requires(::sus::mem::Clone<InnerSizedIter>)
 {
 return Enunerate(CLONE, count_, sus::clone(next_iter_));
 }

constexpr Option<Item> next() noexcept {
 Option<typename InnerSizedIter::Item> item = next_iter_.next();
 if (item.is_none()) {
 return sus::none();
 } else {
 usize count = count_;
 count_ += 1u;
 return sus::some(sus::tuple(
 count, sus::move(item).unwrap_unchecked(::sus::marker::unsafe_fn)));
 }
 }

constexpr SizeHint size_hint() const noexcept {
    return next_iter_.size_hint();
  }

constexpr Option<Item> next_back() noexcept
 requires(DoubleEndedIterator<InnerSizedIter, FromItem> &&
 ExactSizeIterator<InnerSizedIter, FromItem>)
 {
 Option<FromItem> item = next_iter_.next_back();
 if (item.is_none()) {
 return sus::none();
 } else {
 usize len = next_iter_.exact_size_hint();

return sus::some(sus::tuple(
          count_ + len,
          sus::move(item).unwrap_unchecked(::sus::marker::unsafe_fn)));
    }
  }

constexpr usize exact_size_hint() const noexcept
 requires(ExactSizeIterator<InnerSizedIter, FromItem>)
 {
 return next_iter_.exact_size_hint();
 }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
 const noexcept
 requires(TrustedLen<InnerSizedIter>)
 {
 return {};
 }

private:
 template <class U, class V>
 friend class IteratorBase;

explicit constexpr Enumerate(InnerSizedIter&& next_iter)
      : next_iter_(::sus::move(next_iter)) {}

enum Clone { CLONE };
  explicit constexpr Enumerate(Clone, usize count, InnerSizedIter&& next_iter)
      : count_(count), next_iter_(::sus::move(next_iter)) {}

usize count_ = 0u;
  InnerSizedIter next_iter_;

};

}

namespace sus::iter {

using ::sus::mem::relocate_by_memcpy;

template <class InnerSizedIter>
class [[nodiscard]] Take final
 : public IteratorBase<Take<InnerSizedIter>, typename InnerSizedIter::Item> {
 public:
 using Item = InnerSizedIter::Item;

Take(Take&&) = default;
  Take& operator=(Take&&) = default;

constexpr Take clone() const noexcept
 requires(::sus::mem::Clone<InnerSizedIter>)
 {
 return Take(n_, ::sus::clone(next_iter_));
 }

constexpr Option<Item> next() noexcept {
 if (n_ != 0u) {
 n_ -= 1u;
 return next_iter_.next();
 } else {
 return Option<Item>();
 }
 }

constexpr SizeHint size_hint() const noexcept {
    if (n_ == 0u) {
      return {0u, ::sus::some(0u)};
    }

auto [lower, upper] = next_iter_.size_hint();

lower = ::sus::cmp::min(lower, n_);
    upper = ::sus::move(upper)
                .map([this](usize upper) { return ::sus::cmp::min(upper, n_); })
                .or_else([this] { return ::sus::some(n_); });

return {lower, upper};
  }

constexpr Option<Item> next_back() noexcept
 requires(DoubleEndedIterator<InnerSizedIter, Item> &&
 ExactSizeIterator<InnerSizedIter, Item>)
 {
 if (n_ == 0u) {
 return Option<Item>();
 } else {
 usize skip = next_iter_.exact_size_hint().saturating_sub(n_);
 n_ -= 1u;

while (true) {
 if (skip == 0u) return next_iter_.next_back();
 if (next_iter_.next_back().is_none()) return Option<Item>();
 skip -= 1u;
 }
 }
 }

constexpr usize exact_size_hint() const noexcept {
    return ::sus::cmp::min(next_iter_.exact_size_hint(), n_);
  }

constexpr ::sus::iter::__private::TrustedLenMarker trusted_len()
 const noexcept
 requires(TrustedLen<InnerSizedIter>)
 {
 return {};
 }

private:
 template <class U, class V>
 friend class IteratorBase;

explicit constexpr Take(usize n, InnerSizedIter&& next_iter) noexcept
      : n_(n), next_iter_(::sus::move(next_iter)) {}

usize n_;
  InnerSizedIter next_iter_;

};

}

namespace sus::collections {

template <class T>
class Vec final {
 static_assert(
 !std::is_reference_v<T>,
 "Vec<T&> is invalid as Vec must hold value types. Use Vec<T*> instead.");
 static_assert(!std::is_const_v<T>,
 "`Vec<const T>` should be written `const Vec<T>`, as const "
 "applies transitively.");

using A = std::allocator<T>;

static_assert(
 std::allocator_traits<A>::propagate_on_container_move_assignment::value);

static_assert(
 !std::allocator_traits<A>::propagate_on_container_copy_assignment::value);

public:

constexpr Vec(::sus::marker::EmptyMarker) : Vec() {}

template <std::convertible_to<T>... Ts>
 explicit constexpr Vec(Ts&&... values) noexcept
 : Vec(FROM_PARTS, std::allocator<T>(), sizeof...(values), nullptr,
 0_usize) {
 if constexpr (sizeof...(values) > 0u) {
 data_ = std::allocator_traits<A>::allocate(allocator_, sizeof...(values));
 }
 (..., push_with_capacity_internal(::sus::forward<Ts>(values)));
 }

__attribute__((pure)) static constexpr Vec with_capacity(usize capacity) noexcept {
 check(::sus::mem::size_of<T>() * capacity <= ::sus::mog<usize>(isize::MAX));
 return Vec(WITH_CAPACITY, std::allocator<T>(), capacity);
 }

__attribute__((pure)) static constexpr Vec from_raw_parts(::sus::marker::UnsafeFnMarker,
 T* ptr, usize length,
 usize capacity) noexcept {
 return Vec(FROM_PARTS, std::allocator<T>(), capacity, ptr, length);
 }

static constexpr Vec from(::sus::Slice<T> slice) noexcept
 requires(sus::mem::Clone<T>)
 {
 auto v = Vec::with_capacity(slice.len());
 for (const T& t : slice) v.push_with_capacity_internal(::sus::clone(t));
 return v;
 }

static constexpr Vec from(::sus::SliceMut<T> slice) noexcept
 requires(sus::mem::Clone<T>)
 {
 auto v = Vec::with_capacity(slice.len());
 for (const T& t : slice) v.push_with_capacity_internal(::sus::clone(t));
 return v;
 }

template <class C, size_t N>
 requires(std::same_as<T, u8> &&
 (std::same_as<C, char> || std::same_as<C, signed char> ||
 std::same_as<C, unsigned char>) &&
 N <= ::sus::mog<usize>(isize::MAX))
 static constexpr Vec from(const C (&arr)[N]) {
 auto s = sus::Slice<C>::from(arr);
 auto v = Vec::with_capacity(N - 1);
 for (auto c : s[sus::ops::RangeTo<usize>(N - 1)])
 v.push_with_capacity_internal(sus::mog<uint8_t>(c));
 ::sus::check(s[N - 1] == 0);
 return v;
 }

constexpr ~Vec() {

if (is_alloced()) free_storage();
  }

constexpr Vec(Vec&& o) noexcept
      : allocator_(::sus::move(o).allocator_),
        capacity_(::sus::mem::replace(o.capacity_, kMovedFromCapacity)),
        iter_refs_(o.iter_refs_.take_for_owner()),
        data_(::sus::mem::replace(o.data_, nullptr)),
        len_(::sus::mem::replace(o.len_, kMovedFromLen)) {
    check(!is_moved_from() && !has_iterators());
  }

constexpr Vec& operator=(Vec&& o) noexcept {
    check(!o.is_moved_from());
    check(!has_iterators());
    check(!o.has_iterators());
    if (is_alloced()) free_storage();
    allocator_ = ::sus::move(o).allocator_;
    capacity_ = ::sus::mem::replace(o.capacity_, kMovedFromCapacity);
    iter_refs_ = o.iter_refs_.take_for_owner();
    data_ = ::sus::mem::replace(o.data_, nullptr);
    len_ = ::sus::mem::replace(o.len_, kMovedFromLen);
    return *this;
  }

constexpr Vec clone() const& noexcept
 requires(::sus::mem::Clone<T>)
 {
 check(!is_moved_from());
 auto v = Vec(
 WITH_CAPACITY,

std::allocator_traits<A>::select_on_container_copy_construction(
 allocator_),
 capacity_);
 const auto self_len = len_;
 for (usize i = self_len; i > 0u; i -= 1u) {
 std::construct_at(v.data_ + i - 1u, ::sus::clone(*(data_ + i - 1u)));
 }
 v.len_ = self_len;
 return v;
 }

constexpr void clone_from(const Vec& source) noexcept
 requires(!std::allocator_traits<
 A>::propagate_on_container_copy_assignment::value)
 {
 check(!is_moved_from() && !has_iterators());

truncate(source.len());

auto [init, tail] = source.split_at(len_);

clone_from_slice(init);
    extend_from_slice(tail);
  }

constexpr Drain<T> drain(::sus::ops::RangeBounds<usize> auto range) noexcept {
 check(!is_moved_from() && !has_iterators());
 ::sus::ops::Range<usize> bounded_range =
 range.start_at(range.start_bound().unwrap_or(0u))
 .end_at(range.end_bound().unwrap_or(len_));
 return Drain<T>(::sus::move(*this), bounded_range);
 }

constexpr ::sus::Tuple<T*, usize, usize> into_raw_parts() && noexcept {
 check(!is_moved_from() && !has_iterators());
 return sus::Tuple(::sus::mem::replace(data_, nullptr),
 ::sus::mem::replace(len_, kMovedFromLen),
 ::sus::mem::replace(capacity_, kMovedFromCapacity));
 }

__attribute__((pure)) constexpr inline usize capacity() const& noexcept {
    check(!is_moved_from());
    return capacity_;
  }

constexpr void clear() noexcept {
    check(!is_moved_from() && !has_iterators());
    destroy_storage_objects();
    len_ = 0u;
  }

constexpr void extend(sus::iter::IntoIterator<const T&> auto&& ii) noexcept
 requires(sus::mem::Copy<T> &&
 ::sus::mem::IsMoveRef<decltype(ii)>)
 {
 check(!is_moved_from() && !has_iterators());

sus::iter::IterRef ref = iter_refs_.to_iter_from_owner();

auto&& it = sus::move(ii).into_iter();
 const usize self_len = len_;
 if constexpr (sus::iter::TrustedLen<decltype(it)>) {
 const auto [lower, upper] = it.size_hint();

::sus::check_with_message(upper.is_some(), "capacity overflow");
                                                ;
      {
        T* ptr = reserve_internal(lower) + self_len;
        for (const T& t : it) {
          std::construct_at(ptr, t);
          ptr += 1u;
        }
      }

len_ = self_len + lower;
 } else {
 const usize lower = it.size_hint().lower;
 if (sus::Option<const T&> first = it.next(); first.is_some()) {
 const usize r = sus::cmp::max(lower, 1_usize);
 T* ptr = reserve_internal(r) + self_len;
 std::construct_at(ptr, sus::move(first).unwrap());

usize inserted = 1u;
        for (const T& t : it.by_ref().take(r - 1u)) {
          std::construct_at(ptr + inserted, t);
          inserted += 1u;
        }

len_ = self_len + inserted;
        for (const T& t : it) {
          reserve_allocated_internal(1u);
          push_with_capacity_internal(t);
        }
      }
    }
  }

constexpr void extend(sus::iter::IntoIterator<T> auto&& ii) noexcept
 requires(::sus::mem::IsMoveRef<decltype(ii)>)
 {
 check(!is_moved_from() && !has_iterators());

sus::iter::IterRef ref = iter_refs_.to_iter_from_owner();

auto&& it = sus::move(ii).into_iter();
 const usize self_len = len_;
 if constexpr (sus::iter::TrustedLen<decltype(it)>) {
 const auto [lower, upper] = it.size_hint();

::sus::check_with_message(upper.is_some(), "capacity overflow");
                                                ;
      {
        T* ptr = reserve_internal(lower) + self_len;
        for (T&& t : it) {
          std::construct_at(ptr, ::sus::move(t));
          ptr += 1u;
        }
      }

len_ = self_len + lower;
 } else {
 const usize lower = it.size_hint().lower;
 if (sus::Option<T> first = it.next(); first.is_some()) {
 const usize r = sus::cmp::max(lower, 1_usize);
 T* ptr = reserve_internal(r) + self_len;
 std::construct_at(ptr, sus::move(first).unwrap());

usize inserted = 1u;
        for (T&& t : it.by_ref().take(r - 1u)) {
          std::construct_at(ptr + inserted, ::sus::move(t));
          inserted += 1u;
        }

len_ = self_len + inserted;
        for (T&& t : it) {
          reserve_allocated_internal(1u);
          push_with_capacity_internal(::sus::move(t));
        }
      }
    }
  }

constexpr void extend_from_slice(::sus::collections::Slice<T> s) noexcept
 requires(sus::mem::Clone<T>)
 {
 check(!is_moved_from() && !has_iterators());
 if (s.is_empty()) {
 return;
 }
 const auto self_len = len_;
 const auto slice_len = s.len();
 const T* slice_ptr = s.as_ptr();
 if (is_alloced()) {

::sus::check(!(slice_ptr >= data_ && slice_ptr <= data_ + self_len));
 reserve_allocated_internal(slice_len);
 } else {
 reserve_internal(slice_len);
 }
 if constexpr (sus::mem::TrivialCopy<T>) {
 ::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, slice_ptr,
 data_ + self_len, slice_len);
 len_ += slice_len;
 } else {
 for (const T& t : s) push_with_capacity_internal(::sus::clone(t));
 }
 }

constexpr void grow_to_exact(usize cap) noexcept {
    check(!is_moved_from() && !has_iterators());
    reserve_exact_internal(cap - len_);
  }

constexpr Option<T> pop() noexcept {
 check(!is_moved_from() && !has_iterators());
 const auto self_len = len_;
 if (self_len > 0u) {
 auto o = Option<T>(sus::move(
 get_unchecked_mut(::sus::marker::unsafe_fn, self_len - 1u)));
 if constexpr (!std::is_trivially_destructible_v<T>)
 std::destroy_at(as_mut_ptr() + self_len - 1u);
 len_ -= 1u;
 return o;
 } else {
 return Option<T>();
 }
 }

constexpr void push(T t) noexcept
 requires(::sus::mem::Move<T>)
 {
 check(!is_moved_from() && !has_iterators());
 reserve_internal(1_usize);
 push_with_capacity_internal(::sus::move(t));
 }

constexpr void reserve(usize additional) noexcept {
    check(!is_moved_from() && !has_iterators());
    reserve_internal(additional);
  }

constexpr void reserve_exact(usize additional) noexcept {
    check(!is_moved_from() && !has_iterators());
    reserve_exact_internal(additional);
  }

constexpr void set_len(::sus::marker::UnsafeFnMarker,
                         usize new_len) noexcept {
    check(!is_moved_from());
                                         ;
    len_ = new_len;
  }

constexpr void truncate(usize len) noexcept {
 if (len > len_) return;
 const auto remaining_len = len_ - len;
 if constexpr (!std::is_trivially_destructible_v<T>) {
 for (usize i = remaining_len; i > 0u; i -= 1u)
 std::destroy_at(data_ + len + i - 1u);
 }
 len_ = len;
 }

template <class... Us>
 constexpr void emplace(Us&&... args) noexcept
 requires(::sus::mem::Move<T> &&
 !(sizeof...(Us) == 1u &&
 (... && std::same_as<std::decay_t<T>, std::decay_t<Us>>)))
 {
 check(!is_moved_from() && !has_iterators());
 reserve_internal(1_usize);
 std::construct_at(data_ + len_, ::sus::forward<Us>(args)...);
 len_ += 1u;
 }

__attribute__((pure)) constexpr Slice<T> as_slice() const& noexcept [[clang::lifetimebound]] {
 return *this;
 }
 constexpr Slice<T> as_slice() && = delete;

__attribute__((pure)) constexpr SliceMut<T> as_mut_slice() & noexcept [[clang::lifetimebound]] {
 return *this;
 }

constexpr VecIntoIter<T> into_iter() && noexcept
 requires(::sus::mem::Move<T>)
 {
 check(!is_moved_from());
 return VecIntoIter<T>(::sus::move(*this));
 }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Vec<T>& l, const Vec& r) noexcept {
 return l.as_slice() == r.as_slice();
 }

template <class U>
 requires(!::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Vec<T>& l, const Vec& r) = delete;

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Vec<T>& l,
 const Slice& r) noexcept {
 return l.as_slice() == r;
 }

template <class U>
 requires(::sus::cmp::Eq<T, U>)
 friend constexpr bool operator==(const Vec<T>& l,
 const SliceMut& r) noexcept {
 return l.as_slice() == r.as_slice();
 }

__attribute__((pure)) constexpr const T& operator[](::sus::num::usize i) const& noexcept {
 ::sus::check(i < len_);
 return *(as_ptr() + i);
 }

constexpr const T& operator[](::sus::num::usize i) && = delete;

__attribute__((pure)) constexpr T& operator[](::sus::num::usize i) & noexcept {
 check(i < len_);
 return *(as_mut_ptr() + i);
 }

__attribute__((pure)) constexpr Slice<T> operator[](
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 const& noexcept {
 const ::sus::num::usize length = len_;
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(length);
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 ::sus::check(rlen <= length);

::sus::check(rstart <= length && rstart <= length - rlen);
 return Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(),
 as_ptr() + rstart, rlen);
 }

constexpr Slice<T> operator[](
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range) && = delete;

__attribute__((pure)) constexpr SliceMut<T> operator[](
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range) & noexcept {
 const ::sus::num::usize length = len_;
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(length);
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 ::sus::check(rlen <= length);

::sus::check(rstart <= length && rstart <= length - rlen);
 return SliceMut<T>::from_raw_collection_mut(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(),
 as_mut_ptr() + rstart, rlen);
 }

__attribute__((pure)) constexpr operator Slice<T>() const& noexcept {
 check(!is_moved_from());
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), data_, len_);
 }
 __attribute__((pure)) constexpr operator Slice<T>() && = delete;
 __attribute__((pure)) constexpr operator Slice<T>() & noexcept {
 check(!is_moved_from());
 return Slice<T>::from_raw_collection(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), data_, len_);
 }

__attribute__((pure)) constexpr operator SliceMut<T>() & noexcept {
 check(!is_moved_from());
 return SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), data_, len_);
 }

__attribute__((pure)) constexpr inline bool is_empty() const& noexcept {
  return len() == 0u;
}

__attribute__((pure)) constexpr inline ::sus::num::usize len() const& noexcept {
  return len_;
}

__attribute__((pure)) constexpr inline const T* as_ptr() const& noexcept {
  return data_;
}

constexpr inline const T* as_ptr() && = delete;

__attribute__((pure)) constexpr ::sus::ops::Range<const T*> as_ptr_range() const& noexcept {
 return ::sus::ops::Range<const T*>(as_ptr(), as_ptr() + len());
}

constexpr ::sus::ops::Range<const T*> as_ptr_range() && = delete;

::sus::num::usize size = len();
 ::sus::num::usize left = 0u;
 ::sus::num::usize right = size;
 while (left < right) {
 auto mid = left + size / 2u;

auto cmp =
        ::sus::fn::call_mut(f, get_unchecked(::sus::marker::unsafe_fn, mid));

if (cmp == std::strong_ordering::less) {
      left = mid + 1u;
    } else if (cmp == std::strong_ordering::greater) {
      right = mid;
    } else {

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(mid.primitive_value < len_.primitive_value)

#pragma clang diagnostic pop
                                                                 ;
      return ::sus::ok(mid);
    }

size = right - left;
  }

static_assert(std::same_as<std::decay_t<decltype(::sus::marker::unsafe_fn)>, ::sus::marker::UnsafeFnMarker>);

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wassume"

__builtin_assume(left.primitive_value <= len_.primitive_value)

#pragma clang diagnostic pop
                                                               ;
  return ::sus::err(left);
}

constexpr Chunks<T> chunks(::sus::num::usize chunk_size) const& noexcept {
 return Chunks<T>(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr Chunks<T> chunks(::sus::num::usize chunk_size) && = delete;

constexpr ChunksExact<T> chunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return ChunksExact<T>::with_slice(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr ChunksExact<T> chunks_exact(::sus::num::usize chunk_size) && = delete;

using ConcatOutputType = ::sus::collections::Vec<T>;

constexpr void concat_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

constexpr ::sus::Option<const T&> first() && = delete;

constexpr Option<const T&> get(::sus::num::usize i) && = delete;

constexpr inline const T& get_unchecked(::sus::marker::UnsafeFnMarker,
                                        ::sus::num::usize i) && = delete;

constexpr Option<Slice<T>> get_range(
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range) && = delete;

constexpr Slice<T> get_range_unchecked(
 ::sus::marker::UnsafeFnMarker,
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range) && = delete;

__attribute__((pure)) constexpr SliceIter<const T&> iter() const& noexcept {
 return SliceIter<const T&>(iter_refs_.to_iter_from_owner(), as_ptr(), len());
}

constexpr SliceIter<const T&> iter() && = delete;

using JoinOutputType = ::sus::collections::Vec<T>;

constexpr void join_into(::sus::collections::Vec<T>& vec) const& noexcept
 requires(::sus::mem::Clone<T>)
{
 vec.extend_from_slice(*this);
}

constexpr ::sus::Option<const T&> last() && = delete;

constexpr RChunks<T> rchunks(::sus::num::usize chunk_size) const& noexcept {
 return RChunks<T>(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr RChunks<T> rchunks(::sus::num::usize chunk_size) && = delete;

constexpr RChunksExact<T> rchunks_exact(
 ::sus::num::usize chunk_size) const& noexcept {
 return RChunksExact<T>::with_slice(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr RChunksExact<T> rchunks_exact(::sus::num::usize chunk_size) && =
 delete;

constexpr ::sus::collections::Vec<T> repeat(usize n) const& noexcept
 requires(::sus::mem::TrivialCopy<T>)
{
 auto buf = ::sus::collections::Vec<T>();
 if (n == 0u) return buf;

const usize l = len();

const usize capacity = l.saturating_mul(n);
  buf.reserve(capacity);

buf.extend(iter());
  {
    usize m = n >> 1u;

while (m > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                      buf.as_mut_ptr() + buf.len(), buf.len());

const usize buf_len = buf.len();
      buf.set_len(::sus::marker::unsafe_fn, buf_len * 2u);
      m >>= 1u;
    }
  }

const usize rem_len = capacity - buf.len();
  if (rem_len > 0u) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, buf.as_ptr(),
                                    buf.as_mut_ptr() + buf.len(), rem_len);

buf.set_len(::sus::marker::unsafe_fn, capacity);
  }
  return buf;
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> rsplit(Pred) && = delete;

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplit<T, Pred> rsplitn(usize n, Pred pred) && = delete;

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> split(Pred pred) const& noexcept {
 return Split<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> split(Pred) && = delete;

constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at(::sus::num::usize mid) && =
 delete;

__attribute__((pure)) constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at_unchecked(
 ::sus::marker::UnsafeFnMarker, ::sus::num::usize mid) const& noexcept {

;

const ::sus::num::usize rem =
      len().unchecked_sub(::sus::marker::unsafe_fn, mid);

return ::sus::Tuple<Slice<T>, Slice<T>>(
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(), as_ptr(), mid),
 Slice<T>::from_raw_collection(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(), as_ptr() + mid, rem));
}

constexpr ::sus::Tuple<Slice<T>, Slice<T>> split_at_unchecked(
 ::sus::marker::UnsafeFnMarker, ::sus::num::usize mid) && = delete;

constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_first() && =
 delete;

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitInclusive<T, Pred> split_inclusive(Pred) && = delete;

constexpr ::sus::Option<::sus::Tuple<const T&, Slice<T>>> split_last() && =
 delete;

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr Split<T, Pred> splitn(usize n, Pred pred) && = delete;

constexpr bool starts_with(const Slice<T>& needle) const&
 requires(::sus::cmp::Eq<T>)
{
 const auto n = needle.len();
 return len() >= n && needle == (*this)[::sus::ops::RangeTo(n)];
}

constexpr ::sus::Option<Slice<T>> strip_prefix(const Slice<T>& prefix) const& =
 delete;

constexpr ::sus::Option<Slice<T>> strip_suffix(const Slice<T>& suffix) const& =
 delete;

Vec<T> to_vec() const& noexcept
 requires(::sus::mem::Clone<T>);

__attribute__((pure)) constexpr Windows<T> windows(usize size) const& noexcept {
 ::sus::check(size > 0u);
 return Windows<T>(iter_refs_.to_iter_from_owner(), *this, size);
}

__attribute__((pure)) constexpr inline T* as_mut_ptr() & noexcept {
  return data_;
}

__attribute__((pure)) constexpr ::sus::ops::Range<T*> as_mut_ptr_range()
 & noexcept {
 return ::sus::ops::Range<T*>(as_mut_ptr(), as_mut_ptr() + len());
}

constexpr ChunksExactMut<T> chunks_exact_mut(::sus::num::usize chunk_size)
 & noexcept {
 return ChunksExactMut<T>::with_slice(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr ChunksMut<T> chunks_mut(::sus::num::usize chunk_size)
 & noexcept {
 return ChunksMut<T>(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr void copy_from_slice(const Slice<T>& src) noexcept
 requires(::sus::mem::TrivialCopy<T>)
{
 const ::sus::num::usize src_len = src.len();
 const ::sus::num::usize dst_len = len();
 ::sus::check(dst_len == src_len);

if (std::is_constant_evaluated()) {

if (dst_len > max_len) {
 for (::sus::num::usize i; i < dst_len; i += 1u)
 *(dst_ptr + i) = *(src_ptr + i);
 return;
 }
 }

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, src_ptr, dst_ptr,
                                    dst_len);
  }
}

constexpr void copy_from_slice_unchecked(
 ::sus::marker::UnsafeFnMarker, const Slice<T>& src) noexcept
 requires(std::is_trivially_copy_assignable_v<T>)
{
 const ::sus::num::usize dst_len = len();
 const T* const src_ptr = src.as_ptr();
 T* const dst_ptr = as_mut_ptr();

;

if (std::is_constant_evaluated()) {

constexpr void clone_from_slice(const Slice<T>& src) noexcept
 requires(::sus::mem::Clone<T>)
{
 const ::sus::num::usize src_len = src.len();
 const ::sus::num::usize dst_len = len();
 ::sus::check(dst_len == src_len);
 const T* const src_ptr = src.as_ptr();
 T* dst_ptr = as_mut_ptr();
 for (::sus::num::usize i; i < dst_len; i += 1u) {
 ::sus::clone_into(*(dst_ptr + i), *(src_ptr + i));
 }
}

constexpr void fill(T value) noexcept
 requires(::sus::mem::Clone<T>)
{

T* ptr = as_mut_ptr();
  T* const end_ptr = ptr + len();
  while (ptr != end_ptr) {
    ::sus::clone_into(*ptr, value);
    ptr += 1u;
  }
}

constexpr void fill_with(::sus::fn::FnMut<T()> auto f) noexcept {
 T* ptr = as_mut_ptr();
 T* const end_ptr = ptr + len();
 while (ptr != end_ptr) {
 *ptr = ::sus::fn::call_mut(f);
 ptr += 1u;
 }
}

constexpr void fill_with_default() noexcept
 requires(sus::construct::Default<T>)
{
 T* ptr = as_mut_ptr();
 T* const end_ptr = ptr + len();
 while (ptr != end_ptr) {
 *ptr = T();
 ptr += 1u;
 }
}

__attribute__((pure)) constexpr ::sus::Option<T&> first_mut() & noexcept {
 if (len() > 0u)
 return ::sus::Option<T&>(*as_mut_ptr());
 else
 return ::sus::Option<T&>();
}

__attribute__((pure)) constexpr Option<T&> get_mut(::sus::num::usize i) & noexcept {
 if (i < len()) [[likely]]
 return Option<T&>(get_unchecked_mut(::sus::marker::unsafe_fn, i));
 else
 return Option<T&>();
}

__attribute__((pure)) constexpr inline T& get_unchecked_mut(
    ::sus::marker::UnsafeFnMarker, ::sus::num::usize i) & noexcept {
                                                                ;
  return *(as_mut_ptr() + i);
}

__attribute__((pure)) constexpr Option<SliceMut<T>> get_range_mut(
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 & noexcept {
 const ::sus::num::usize length = len();
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(length);
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 if (rlen > length) return sus::none();

if (rstart > length || rstart > length - rlen) return sus::none();
 return Option<SliceMut<T>>(SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), as_mut_ptr() + rstart,
 rlen));
}

__attribute__((pure)) constexpr SliceMut<T> get_range_mut_unchecked(
 ::sus::marker::UnsafeFnMarker,
 const ::sus::ops::RangeBounds<::sus::num::usize> auto range)
 & noexcept {
 const ::sus::num::usize rstart = range.start_bound().unwrap_or(0u);
 const ::sus::num::usize rend = range.end_bound().unwrap_or(len());
 const ::sus::num::usize rlen = rend >= rstart ? rend - rstart : 0u;
 return SliceMut<T>::from_raw_collection_mut(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(),
 as_mut_ptr() + rstart, rlen);
}

__attribute__((pure)) constexpr SliceIterMut<T&> iter_mut() & noexcept {
 return SliceIterMut<T&>(iter_refs_.to_iter_from_owner(), as_mut_ptr(), len());
}

__attribute__((pure)) constexpr ::sus::Option<T&> last_mut() & noexcept {
 const ::sus::num::usize length = len();
 if (length > 0u)
 return ::sus::Option<T&>(*(as_mut_ptr() + length - 1u));
 else
 return ::sus::Option<T&>();
}

constexpr RChunksExactMut<T> rchunks_exact_mut(::sus::num::usize chunk_size)
 & noexcept {
 return RChunksExactMut<T>::with_slice(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr RChunksMut<T> rchunks_mut(::sus::num::usize chunk_size)
 & noexcept {
 return RChunksMut<T>(iter_refs_.to_iter_from_owner(), *this, chunk_size);
}

constexpr void reverse() noexcept
 requires(::sus::mem::Move<T>)
{
 const auto half_len = len() / 2u;
 const auto [start, end] = as_mut_ptr_range();

auto front_half = ::sus::collections::SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), start, half_len);

auto back_half = ::sus::collections::SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), end - half_len, half_len);

for (::sus::num::usize i; i < half_len; i += 1u) {

::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, front_half[i],
                                    back_half[half_len - 1u - i]);
  }
}

void rotate_left(::sus::num::usize mid) noexcept
 requires(::sus::mem::Move<T>)
{
 const ::sus::num::usize length = len();
 ::sus::check(mid <= length);
 const ::sus::num::usize k = length - mid;
 T* const p = as_mut_ptr();

if constexpr (::sus::mem::relocate_by_memcpy<T>) {
 if (!std::is_constant_evaluated()) {

}
  }

if (mid == 0u || k == 0u) return;

for (::sus::num::usize i; i < k; i += 1u) {
 ::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(p + i),
 *(p + mid + i));
 }
 if (k < mid) {

get_range_mut_unchecked(::sus::marker::unsafe_fn, ::sus::ops::RangeFrom(k))
        .rotate_left(mid - k);
  } else if (k > mid && mid % 2u != (k - mid) % 2u) {

if ((k - mid) % 2u == 1u) {

void rotate_right(::sus::num::usize k) noexcept
 requires(::sus::mem::Move<T>)
{
 rotate_left(len() - k);
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitMut<T, Pred> rsplit_mut(Pred pred) & noexcept {
 return RSplitMut<T, Pred>(
 SplitMut<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred)));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr RSplitNMut<T, Pred> rsplitn_mut(usize n,
 Pred pred) & noexcept {
 return RSplitNMut<T, Pred>(
 RSplitMut<T, Pred>(
 SplitMut<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred))),
 n);
}

void sort() noexcept
 requires(::sus::cmp::Ord<T>)
{
 if (len() > ::sus::num::usize(0u)) {
 std::stable_sort(as_mut_ptr(), as_mut_ptr() + len());
 }
}

void sort_by(::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto
 compare) noexcept {
 if (len() > ::sus::num::usize(0u)) {
 std::stable_sort(as_mut_ptr(), as_mut_ptr() + len(),
 [&compare](const T& l, const T& r) {
 return ::sus::fn::call_mut(compare, l, r) < 0;
 });
 }
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_by_key(KeyFn f) noexcept {
 return sort_by([&f](const T& a, const T& b) {
 return ::sus::fn::call_mut(f, a) <=> ::sus::fn::call_mut(f, b);
 });
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_by_cached_key(KeyFn f) noexcept {
 constexpr auto sz_u8 = ::sus::mem::size_of<::sus::Tuple<Key, u8>>();
 constexpr auto sz_u16 = ::sus::mem::size_of<::sus::Tuple<Key, u16>>();
 constexpr auto sz_u32 = ::sus::mem::size_of<::sus::Tuple<Key, u32>>();
 constexpr auto sz_usize = ::sus::mem::size_of<::sus::Tuple<Key, usize>>();

constexpr void sort_unstable() noexcept
 requires(::sus::cmp::Ord<T>)
{
 if (len() > 0u) {
 std::sort(as_mut_ptr(), as_mut_ptr() + len());
 }
}

constexpr void sort_unstable_by(
 ::sus::fn::FnMut<std::weak_ordering(const T&, const T&)> auto compare)
 noexcept {
 if (len() > 0u) {
 std::sort(as_mut_ptr(), as_mut_ptr() + len(),
 [&compare](const T& l, const T& r) {
 return ::sus::fn::call_mut(compare, l, r) < 0;
 });
 }
}

template <::sus::fn::FnMut<::sus::fn::NonVoid(const T&)> KeyFn, int&...,
 class Key = std::invoke_result_t<KeyFn&, const T&>>
 requires(::sus::cmp::Ord<Key>)
void sort_unstable_by_key(KeyFn f) noexcept {
 return sort_unstable_by([&f](const T& a, const T& b) {
 return ::sus::fn::call_mut(f, a) <=> ::sus::fn::call_mut(f, b);
 });
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitMut<T, Pred> split_mut(Pred pred) & noexcept {
 return SplitMut<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Tuple<SliceMut<T>, SliceMut<T>> split_at_mut(
 ::sus::num::usize mid) & noexcept {
 ::sus::check(mid <= len());
 return split_at_mut_unchecked(::sus::marker::unsafe_fn, mid);
}

__attribute__((pure)) constexpr ::sus::Tuple<SliceMut<T>, SliceMut<T>>
split_at_mut_unchecked(::sus::marker::UnsafeFnMarker,
 ::sus::num::usize mid) & noexcept {

;

const ::sus::num::usize rem =
      len().unchecked_sub(::sus::marker::unsafe_fn, mid);

return ::sus::Tuple<SliceMut<T>, SliceMut<T>>(
 SliceMut<T>::from_raw_collection_mut(
 ::sus::marker::unsafe_fn, iter_refs_.to_view_from_owner(), as_mut_ptr(), mid),
 SliceMut<T>::from_raw_collection_mut(::sus::marker::unsafe_fn,
 iter_refs_.to_view_from_owner(),
 as_mut_ptr() + mid, rem));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<T&, SliceMut<T>>>
split_first_mut() & noexcept {
 if (is_empty()) return ::sus::none();
 return ::sus::some(
 ::sus::tuple(*as_mut_ptr(),

get_range_mut_unchecked(::sus::marker::unsafe_fn,
 ::sus::ops::RangeFrom<usize>(1u))));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitInclusiveMut<T, Pred> split_inclusive_mut(Pred pred)
 & noexcept {
 return SplitInclusiveMut<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred));
}

__attribute__((pure)) constexpr ::sus::Option<::sus::Tuple<T&, SliceMut<T>>> split_last_mut()
 & noexcept {
 if (is_empty()) return ::sus::none();
 const usize last = len() - 1u;
 return ::sus::some(
 ::sus::tuple(*(as_mut_ptr() + last),

get_range_mut_unchecked(::sus::marker::unsafe_fn,
 ::sus::ops::RangeTo<usize>(last))));
}

template <::sus::fn::FnMut<bool(const T&)> Pred>
constexpr SplitNMut<T, Pred> splitn_mut(usize n,
 Pred pred) & noexcept {
 return SplitNMut<T, Pred>(
 SplitMut<T, Pred>(iter_refs_.to_iter_from_owner(), *this, ::sus::move(pred)), n);
}

constexpr ::sus::Option<SliceMut<T>> strip_prefix_mut(const Slice<T>& prefix)
 & noexcept
 requires(::sus::cmp::Eq<T>)
{
 const usize n = prefix.len();
 if (n <= len()) {
 auto [head, tail] = split_at_mut(n);
 if (head == prefix) {
 return ::sus::Option<SliceMut<T>>(tail);
 }
 }
 return ::sus::Option<SliceMut<T>>();
}

constexpr ::sus::Option<SliceMut<T>> strip_suffix_mut(const Slice<T>& suffix)
 & noexcept
 requires(::sus::cmp::Eq<T>)
{
 const auto l = len();
 const auto n = suffix.len();
 if (n <= l) {
 auto [head, tail] = split_at_mut(l - n);
 if (tail == suffix) {
 return ::sus::Option<SliceMut<T>>(head);
 }
 }
 return ::sus::Option<SliceMut<T>>();
}

constexpr void swap(usize a, usize b) noexcept {
 ::sus::check(a < len() && b < len());

::sus::mem::swap(*(as_mut_ptr() + a), *(as_mut_ptr() + b));
}

constexpr void swap_nonoverlapping(::sus::marker::UnsafeFnMarker, usize a,
                                   usize b) noexcept {
                                                         ;
                                                                ;
                                                                ;

::sus::mem::swap_nonoverlapping(::sus::marker::unsafe_fn, *(as_mut_ptr() + a),
                                  *(as_mut_ptr() + b));
}

constexpr void swap_unchecked(::sus::marker::UnsafeFnMarker, usize a,
                              usize b) noexcept {
                                                                ;
                                                                ;
  ::sus::mem::swap(*(as_mut_ptr() + a), *(as_mut_ptr() + b));
}

constexpr void swap_with_slice(const SliceMut<T>& other)
 noexcept {
 auto const self_len = len();
 auto const other_len = other.len();
 T* const self_ptr = as_mut_ptr();
 T* const other_ptr = other.as_mut_ptr();

::sus::check(self_len == other_len);
 if (other_ptr <= self_ptr) {
 ::sus::check(other_ptr + other_len <= self_ptr);
 } else {
 ::sus::check(self_ptr + self_len <= other_ptr);
 }

::sus::ptr::swap_nonoverlapping(::sus::marker::unsafe_fn, self_ptr, other_ptr,
                                  self_len);
}

__attribute__((pure)) constexpr WindowsMut<T> windows_mut(usize size) & noexcept {
 ::sus::check(size > 0u);
 return WindowsMut<T>(iter_refs_.to_iter_from_owner(), *this, size);
}

private:
 friend sus::iter::FromIteratorImpl<Vec>;

enum FromParts { FROM_PARTS };
 constexpr Vec(FromParts, std::allocator<T> alloc, usize cap, T* ptr,
 usize len)
 : allocator_(::sus::move(alloc)),
 capacity_(cap),
 iter_refs_(sus::iter::IterRefCounter::for_owner()),
 data_(ptr),
 len_(len) {}

enum WithCapacity { WITH_CAPACITY };
 constexpr Vec(WithCapacity, std::allocator<T> alloc, usize cap)
 : allocator_(::sus::move(alloc)),
 capacity_(0u),
 iter_refs_(sus::iter::IterRefCounter::for_owner()),
 data_(nullptr),
 len_(0u) {

if (cap > 0u) alloc_internal_check_cap(cap);
  }

constexpr usize apply_growth_function(usize additional) const noexcept {
    usize goal = additional + len_;
    usize cap = capacity_;

while (cap < goal) {
 cap = (cap + 1u) * 3u;
 }
 return cap;
 }

constexpr void destroy_storage_objects() {
 if constexpr (!std::is_trivially_destructible_v<T>) {
 for (usize i = len_; i > 0u; i -= 1u) std::destroy_at(data_ + i - 1u);
 }
 }

constexpr void free_storage() {
 destroy_storage_objects();
 std::allocator_traits<std::allocator<T>>::deallocate(allocator_, data_,
 capacity_);
 }

constexpr void push_with_capacity_internal(const T& t) noexcept {
    std::construct_at(data_ + len_, t);
    len_ += 1u;
  }
  constexpr void push_with_capacity_internal(T&& t) noexcept {
    std::construct_at(data_ + len_, ::sus::move(t));
    len_ += 1u;
  }

constexpr T* reserve_internal(usize additional) noexcept {
    T* new_data;
    if (len_ + additional > capacity_) {
      if (!is_alloced()) {
        new_data = alloc_internal_check_cap(additional);
      } else {
        new_data =
            grow_to_internal_check_cap(apply_growth_function(additional));
      }
    } else {
      new_data = data_;
    }
    return new_data;
  }

constexpr T* reserve_exact_internal(usize additional) noexcept {
    const usize cap = len_ + additional;
    T* new_data;
    if (cap > capacity_) {
      if (!is_alloced())
        new_data = alloc_internal_check_cap(cap);
      else
        new_data = grow_to_internal_check_cap(cap);
    } else {
      new_data = data_;
    }
    return new_data;
  }

constexpr T* reserve_allocated_internal(usize additional) noexcept {
                                 ;
    T* new_data;
    if (len_ + additional > capacity_) {

new_data = grow_to_internal_check_cap(apply_growth_function(additional));
    } else {
      new_data = data_;
    }
    return new_data;
  }

constexpr T* alloc_internal_check_cap(usize cap) noexcept;

constexpr T* grow_to_internal_check_cap(usize additional) noexcept;

constexpr inline bool is_alloced() const noexcept {
    return capacity_ > 0_usize;
  }

constexpr inline bool is_moved_from() const noexcept {
    return len_ > capacity_;
  }

constexpr inline bool has_iterators() const noexcept {
    return iter_refs_.count_from_owner() != 0u;
  }

static constexpr usize kMovedFromLen = 1_usize;

static constexpr usize kMovedFromCapacity = 0_usize;

[[no_unique_address]] std::allocator<T> allocator_;
 usize capacity_;

[[no_unique_address]] ::sus::iter::IterRefCounter iter_refs_;
  T* data_;
  usize len_;

};

template <class T, class... Ts>
 requires((... &&
 std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<Ts>>))
Vec(T&&, Ts&&...) -> Vec<std::remove_cvref_t<T>>;

template <class T>
Vec<T> Vec<T>::to_vec() const& noexcept
 requires(::sus::mem::Clone<T>)
{
 auto v = Vec<T>::with_capacity(len_);
 for (::sus::usize i; i < len_; i += 1u) {
 v.push(::sus::clone(*(data_ + i)));
 }
 return v;
}

template <class T>
constexpr T* Vec<T>::alloc_internal_check_cap(usize cap) noexcept {
 ;
 ::sus::check(cap <= ::sus::mog<usize>(isize::MAX));
 T* const new_data = std::allocator_traits<A>::allocate(allocator_, cap);
 data_ = new_data;
 capacity_ = cap;
 return new_data;
}

template <class T>
constexpr T* Vec<T>::grow_to_internal_check_cap(usize cap) noexcept {
 ;
 ;
 ::sus::check(cap <= ::sus::mog<usize>(isize::MAX));
 T* const new_data =
 std::allocator_traits<std::allocator<T>>::allocate(allocator_, cap);
 if constexpr (::sus::mem::relocate_by_memcpy<T>) {
 if (!std::is_constant_evaluated()) {

::sus::ptr::copy_nonoverlapping(::sus::marker::unsafe_fn, data_, new_data,
 capacity_);
 std::allocator_traits<std::allocator<T>>::deallocate(allocator_, data_,
 capacity_);
 data_ = new_data;
 capacity_ = cap;
 return new_data;
 }
 }

for (usize i = len_; i > 0u; i -= 1u) {
 std::construct_at(new_data + i - 1u, ::sus::move(*(data_ + i - 1u)));
 if constexpr (!std::is_trivially_destructible_v<T>)
 std::destroy_at(data_ + i - 1u);
 }
 std::allocator_traits<std::allocator<T>>::deallocate(allocator_, data_,
 capacity_);
 data_ = new_data;
 capacity_ = cap;
 return new_data;
}

}

template <class T>
struct sus::iter::FromIteratorImpl<::sus::collections::Vec<T>> {

static constexpr ::sus::collections::Vec<T> from_iter(
 ::sus::iter::IntoIterator<T> auto&& ii) noexcept
 requires(::sus::mem::Move<T> &&
 ::sus::mem::IsMoveRef<decltype(ii)>)
 {
 auto v = ::sus::collections::Vec<T>();
 v.extend(::sus::move(ii));
 return v;
 }
};

template <class T, class Char>
struct fmt::formatter<::sus::collections::Vec<T>, Char> {
 template <class ParseContext>
 constexpr auto parse(ParseContext& ctx) {
 return underlying_.parse(ctx);
 }

template <class FormatContext>
 constexpr auto format(const ::sus::collections::Vec<T>& vec,
 FormatContext& ctx) const {
 auto out = ctx.out();
 out = fmt::format_to(out, "[");
 for (::sus::num::usize i; i < vec.len(); i += 1u) {
 if (i > 0u) out = fmt::format_to(out, ", ");
 ctx.advance_to(out);
 out = underlying_.format(vec[i], ctx);
 }
 return fmt::format_to(out, "]");
 }

private:
 ::sus::string::__private::AnyFormatter<T, Char> underlying_;
};

namespace sus::collections { using namespace ::sus::string::__private; template< class T , StreamCanReceiveString<char> Sus_StreamType > inline Sus_StreamType& operator<<( Sus_StreamType& stream, const Vec <T>& value ) { static_assert(fmt::is_formattable<Vec <T> >::value); return format_to_stream(stream, fmt::to_string(value)); } };

namespace sus::collections {

using ::sus::iter::begin;

using ::sus::iter::end;
}

namespace sus {
using ::sus::collections::Vec;
}

namespace sus {

namespace num {}

}

namespace sus::num::__private {

template <class T>
 requires(std::is_floating_point_v<T> && ::sus::mem::size_of<T>() <= 8)
__attribute__((const)) inline constexpr std::strong_ordering
float_strong_ordering(T l, T r) noexcept {
 if (into_unsigned_integer(l) == into_unsigned_integer(r))
 return std::strong_ordering::equal;

const bool l_neg = (into_unsigned_integer(l) & high_bit<T>()) != 0;
 const bool r_neg = (into_unsigned_integer(r) & high_bit<T>()) != 0;
 if (l_neg != r_neg) {
 if (l_neg)
 return std::strong_ordering::less;
 else
 return std::strong_ordering::greater;
 }

const bool l_nan = float_is_nan(l);
  const bool r_nan = float_is_nan(r);
  if (l_nan != r_nan) {
    if (l_neg == l_nan)
      return std::strong_ordering::less;
    else
      return std::strong_ordering::greater;
  }
  if (l_nan && r_nan) {
    const bool l_quiet = float_is_nan_quiet(l);
    const bool r_quiet = float_is_nan_quiet(r);
    if (l_quiet != r_quiet) {
      if (l_neg == float_is_nan_quiet(l))
        return std::strong_ordering::less;
      else
        return std::strong_ordering::greater;
    } else {
      if (l_neg) {
        return std::strong_order(into_unsigned_integer(r),
                                 into_unsigned_integer(l));
      } else {
        return std::strong_order(into_unsigned_integer(l),
                                 into_unsigned_integer(r));
      }
    }
  }

if (l < r)
 return std::strong_ordering::less;
 else
 return std::strong_ordering::greater;
}

}

namespace sus::num {

struct [[clang::trivial_abi]] f32 final {

float primitive_value = float{0.0};

static const float MIN_PRIMITIVE;

static const float MAX_PRIMITIVE;

static const f32 MIN;

static const f32 MAX;

static const u32 RADIX;

static const u32 MANTISSA_DIGITS;

static const u32 DIGITS;

static const f32 EPSILON;

static const f32 MIN_POSITIVE;

static const i32 MIN_EXP;

static const i32 MAX_EXP;

static const i32 MIN_10_EXP;

static const i32 MAX_10_EXP;

static const f32 NAN;

static const f32 INFINITY;

static const f32 NEG_INFINITY;

struct consts {

static const f32 E;

static const f32 FRAC_1_PI;

static const f32 FRAC_1_SQRT_2;

static const f32 FRAC_2_PI;

static const f32 FRAC_2_SQRT_PI;

static const f32 FRAC_PI_2;

static const f32 FRAC_PI_3;

static const f32 FRAC_PI_4;

static const f32 FRAC_PI_6;

static const f32 FRAC_PI_8;

static const f32 LN_2;

static const f32 LN_10;

static const f32 LOG2_10;

static const f32 LOG2_E;

static const f32 LOG10_2;

static const f32 LOG10_E;

static const f32 PI;

static const f32 SQRT_2;

static const f32 TAU;
};

constexpr inline f32() noexcept = default;

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<float>())
constexpr inline f32(F v) noexcept : primitive_value(v.primitive_value) {}

template <PrimitiveFloat P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<float>())
constexpr inline f32(P v) noexcept : primitive_value(v) {}

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<float>())
__attribute__((pure)) static constexpr f32 from(F f) noexcept {
 return f32(f);
}

template <PrimitiveFloat F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<float>())
__attribute__((pure)) static constexpr f32 from(F f) noexcept {
 return f32(f);
}

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<float>())
constexpr inline f32& operator=(F v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <PrimitiveFloat P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<float>())
constexpr inline f32& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

static constexpr f32 from_sum(::sus::iter::Iterator<f32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = f32(float{0u});
 for (f32 i : ::sus::move(it)) p += i;
 return p;
}

static constexpr f32 from_product(
 ::sus::iter::Iterator<f32> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = f32(float{1u});
 for (f32 i : ::sus::move(it)) p *= i;
 return p;
}

template <PrimitiveFloat U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<float>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr float* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const float* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const float* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f32 l, f32 r) noexcept {
 return (l.primitive_value <=> r.primitive_value) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f32 l, Float auto r) noexcept {
 return (l.primitive_value <=> r.primitive_value) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f32 l, PrimitiveFloat auto r) noexcept {
 return (l.primitive_value <=> r) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f32 l, f32 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f32 l, Float auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f32 l, PrimitiveFloat auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr std::weak_ordering total_cmp(f32 other) const& noexcept {
  return __private::float_strong_ordering(primitive_value,
                                          other.primitive_value);
}

__attribute__((pure)) constexpr inline f32 operator-() const {
  return f32(-primitive_value);
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline f32 operator+(
    f32 l, f32 r) noexcept {
  return l.primitive_value + r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator+(
 f32 l, U r) noexcept {
 return l + f32(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator+(
 U l, f32 r) noexcept {
 return f32(l) + r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator+(f32 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator+(U l, f32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f32 operator-(
    f32 l, f32 r) noexcept {
  return l.primitive_value - r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator-(
 f32 l, U r) noexcept {
 return l - f32(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator-(
 U l, f32 r) noexcept {
 return f32(l) - r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator-(f32 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator-(U l, f32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f32 operator*(
    f32 l, f32 r) noexcept {
  return l.primitive_value * r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator*(
 f32 l, U r) noexcept {
 return l * f32(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator*(
 U l, f32 r) noexcept {
 return f32(l) * r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator*(f32 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator*(U l, f32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f32 operator/(
    f32 l, f32 r) noexcept {
  return l.primitive_value / r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator/(
 f32 l, U r) noexcept {
 return l / f32(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator/(
 U l, f32 r) noexcept {
 return f32(l) / r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator/(f32 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator/(U l, f32 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f32 operator%(
    f32 l, f32 r) noexcept {
  const auto x = l.primitive_value;
  const auto y = r.primitive_value;
  return x - __private::truncate_float(x / y) * y;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator%(
 f32 l, U r) noexcept {
 return l % f32(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f32>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f32 operator%(
 U l, f32 r) noexcept {
 return f32(l) % r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator%(f32 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f32>)
friend constexpr inline f32 operator%(U l, f32 r) noexcept = delete;

constexpr inline void operator+=(f32 r) & noexcept {
  primitive_value += r.primitive_value;
}

constexpr inline void operator-=(f32 r) & noexcept {
  primitive_value -= r.primitive_value;
}

constexpr inline void operator*=(f32 r) & noexcept {
  primitive_value *= r.primitive_value;
}

constexpr inline void operator/=(f32 r) & noexcept {
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(f32 r) & noexcept {
  const auto x = primitive_value;
  const auto y = r.primitive_value;
  primitive_value = x - __private::truncate_float(x / y) * y;
}

__attribute__((pure)) inline f32 abs() const& noexcept {
 return __private::into_float(
 __private::into_unsigned_integer(primitive_value) &
 ~__private::high_bit<float>());
}

__attribute__((pure)) inline f32 acos() const& noexcept {
 if (primitive_value < float{-1} || primitive_value > float{1})
 [[unlikely]]
 return NAN;

return static_cast<float>(::acos(primitive_value));
}

__attribute__((pure)) inline f32 acosh() const& noexcept {
 if (primitive_value < float{-1}) [[unlikely]]
 return NAN;

return static_cast<float>(::acosh(primitive_value));
}

__attribute__((pure)) inline f32 asin() const& noexcept {
 if (primitive_value < float{-1} || primitive_value > float{1})
 [[unlikely]]
 return NAN;

return static_cast<float>(::asin(primitive_value));
}

__attribute__((pure)) inline f32 asinh() const& noexcept {
 if (primitive_value < float{-1}) [[unlikely]]
 return NAN;

return static_cast<float>(::asinh(primitive_value));
}

__attribute__((pure)) inline f32 atan() const& noexcept {

return static_cast<float>(::atan(primitive_value));
}

__attribute__((pure)) inline f32 atan2(f32 other) const& noexcept {

return static_cast<float>(
 ::atan2(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f32 atanh() const& noexcept {

return static_cast<float>(::atanh(primitive_value));
}

__attribute__((pure)) inline f32 cbrt() const& noexcept {

return static_cast<float>(::cbrt(primitive_value));
}

__attribute__((pure)) inline f32 ceil() const& noexcept {

return static_cast<float>(::ceil(primitive_value));
}

__attribute__((pure)) inline f32 copysign(f32 sign) const& noexcept {

return static_cast<float>(
 ::copysign(primitive_value, sign.primitive_value));
}

__attribute__((pure)) inline f32 cos() const& noexcept {

return static_cast<float>(::cos(primitive_value));
}

__attribute__((pure)) inline f32 cosh() const& noexcept {

return static_cast<float>(::cosh(primitive_value));
}

__attribute__((pure)) inline f32 exp() const& noexcept {

return static_cast<float>(::exp(primitive_value));
}

__attribute__((pure)) inline f32 exp2() const& noexcept {

return static_cast<float>(::exp2(primitive_value));
}

__attribute__((pure)) inline f32 exp_m1() const& noexcept {

return static_cast<float>(::expm1(primitive_value));
}

__attribute__((pure)) inline f32 floor() const& noexcept {

return static_cast<float>(::floor(primitive_value));
}

__attribute__((pure)) inline f32 hypot(f32 other) const& noexcept {

return static_cast<float>(
 ::hypot(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f32 ln() const& noexcept {

return static_cast<float>(::log(primitive_value));
}

__attribute__((pure)) inline f32 ln_1p() const& noexcept {

return static_cast<float>(::log1p(primitive_value));
}

__attribute__((pure)) inline f32 log10() const& noexcept {

return static_cast<float>(::log10(primitive_value));
}

__attribute__((pure)) inline f32 log2() const& noexcept {

return static_cast<float>(::log2(primitive_value));
}

__attribute__((pure)) inline f32 log(f32 base) const& noexcept {
  return ln() / base.ln();
}

__attribute__((pure)) inline f32 max(f32 other) const& noexcept {

return static_cast<float>(
 ::fmax(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f32 min(f32 other) const& noexcept {

return static_cast<float>(
 ::fmin(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f32 mul_add(f32 a, f32 b) const& noexcept {

return static_cast<float>(
 ::fma(primitive_value, a.primitive_value, b.primitive_value));
}

__attribute__((pure)) inline f32 next_toward(f32 toward) const& noexcept {
  return __private::next_toward(primitive_value, toward.primitive_value);
}

__attribute__((pure)) inline f32 powf(f32 n) const& noexcept {

return static_cast<float>(::pow(primitive_value, n.primitive_value));
}

__attribute__((pure)) inline f32 powi(i32 n) const& noexcept {

return static_cast<float>(
 ::pow(primitive_value, int{n.primitive_value}));
}

__attribute__((pure)) inline f32 recip() const& noexcept {
  return float{1} / primitive_value;
}

__attribute__((pure)) inline f32 round() const& noexcept {
  return __private::float_round(primitive_value);
}

__attribute__((pure)) inline f32 round_ties() const& noexcept {
  return __private::float_round_ties_by_mode(primitive_value);
}

__attribute__((pure)) inline i8 round_to_i8() const& noexcept {
 return __private::float_round_to<decltype(i8::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i16 round_to_i16() const& noexcept {
 return __private::float_round_to<decltype(i16::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i32 round_to_i32() const& noexcept {
 return __private::float_round_to<decltype(i32::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i64 round_to_i64() const& noexcept {
 return __private::float_round_to<decltype(i64::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline isize round_to_isize() const& noexcept {
 return __private::float_round_to<decltype(isize::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline f32 signum() const& noexcept {

return __private::float_signum(primitive_value);
}

__attribute__((pure)) inline f32 sin() const& noexcept {

return static_cast<float>(::sin(primitive_value));
}

__attribute__((pure)) inline f32 sinh() const& noexcept {

return static_cast<float>(::sinh(primitive_value));
}

__attribute__((pure)) inline f32 sqrt() const& noexcept {
 if (primitive_value < -float{0}) [[unlikely]]
 return NAN;

return static_cast<float>(::sqrt(primitive_value));
}

__attribute__((pure)) inline f32 tan() const& noexcept {

return static_cast<float>(::tan(primitive_value));
}

__attribute__((pure)) inline f32 tanh() const& noexcept {

return static_cast<float>(::tanh(primitive_value));
}

__attribute__((pure)) inline f32 fract() const& noexcept {
  return primitive_value - __private::truncate_float(primitive_value);
}

__attribute__((pure)) inline f32 trunc() const& noexcept {
  return __private::truncate_float(primitive_value);
}

__attribute__((pure)) inline f32 to_degrees() const& noexcept {

constexpr auto PIS_IN_180 = float{57.2957795130823208767981548141051703};
  return primitive_value * PIS_IN_180;
}

__attribute__((pure)) inline f32 to_radians() const& noexcept {
  return primitive_value * (consts::PI.primitive_value / float{180});
}

template <Integer I>
__attribute__((pure)) constexpr inline I to_int_unchecked(
 ::sus::marker::UnsafeFnMarker) const& noexcept {
 return static_cast<decltype(I::primitive_value)>(primitive_value);
}

__attribute__((pure)) static f32 from_bits(u32 v) noexcept {
 return std::bit_cast<f32>(v);
}

__attribute__((pure)) constexpr inline u32 to_bits() const& noexcept {
 return std::bit_cast<decltype(u32::primitive_value)>(primitive_value);
}

__attribute__((pure)) constexpr inline FpCategory classify() const& noexcept {
  return __private::float_category(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_finite() const& noexcept {
  return !__private::float_is_inf_or_nan(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_infinite() const& noexcept {
  return __private::float_is_inf(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_nan() const& noexcept {
  return __private::float_is_nan(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_normal() const& noexcept {
  return __private::float_is_normal(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_sign_negative() const& noexcept {
  return __private::float_signbit(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_sign_positive() const& noexcept {
  return !__private::float_signbit(primitive_value);
}

__attribute__((pure)) constexpr inline bool is_subnormal() const& noexcept {
  return !__private::float_is_zero(primitive_value) &&
         __private::float_nonzero_is_subnormal(primitive_value);
}

__attribute__((pure)) constexpr inline f32 clamp(f32 min, f32 max) const& noexcept {
 ::sus::check(!min.is_nan() && !max.is_nan() &&
 min.primitive_value <= max.primitive_value);

return __private::float_clamp(primitive_value, min.primitive_value,
                                max.primitive_value);
}

__attribute__((pure)) f32 div_euclid(f32 rhs) const& noexcept {
 const auto q = (*this / rhs).trunc();
 if (*this % rhs < float{0}) {
 if (rhs > f32{float{0}})
 return q - f32{float{1}};
 else
 return q + f32{float{1}};
 }
 return q;
}

__attribute__((pure)) f32 rem_euclid(f32 rhs) const& noexcept {
 const auto r = *this % rhs;
 if (r < f32{float{0}})
 return r + rhs.abs();
 else
 return r;
}

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<float>()>
to_be_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<float>()>
to_le_bytes() const& noexcept;

__attribute__((pure)) constexpr ::sus::collections::Array<u8,
 ::sus::mem::size_of<float>()>
to_ne_bytes() const& noexcept;

__attribute__((pure)) static f32 from_be_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<float>()>&
 bytes) noexcept;

__attribute__((pure)) static f32 from_le_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<float>()>&
 bytes) noexcept;

__attribute__((pure)) static f32 from_ne_bytes(
 const ::sus::collections::Array<u8, ::sus::mem::size_of<float>()>&
 bytes) noexcept;

};

inline constexpr float f32::MIN_PRIMITIVE =
 __private::min_value<float>();
inline constexpr float f32::MAX_PRIMITIVE =
 __private::max_value<float>();
inline constexpr f32 f32::MIN = f32(f32::MIN_PRIMITIVE);
inline constexpr f32 f32::MAX = f32(f32::MAX_PRIMITIVE);
inline constexpr u32 f32::RADIX = __private::radix<float>();
inline constexpr u32 f32::MANTISSA_DIGITS =
 __private::num_mantissa_digits<float>();
inline constexpr u32 f32::DIGITS = __private::num_digits<float>();
inline constexpr f32 f32::EPSILON = f32(__private::epsilon<float>());
inline constexpr f32 f32::MIN_POSITIVE =
 f32(__private::min_positive_value<float>());
inline constexpr i32 f32::MIN_EXP = __private::min_exp<float>();
inline constexpr i32 f32::MAX_EXP = __private::max_exp<float>();
inline constexpr i32 f32::MIN_10_EXP = __private::min_10_exp<float>();
inline constexpr i32 f32::MAX_10_EXP = __private::max_10_exp<float>();
inline constexpr f32 f32::NAN = f32(__private::nan<float>());
inline constexpr f32 f32::INFINITY =
 f32(__private::infinity<float>());
inline constexpr f32 f32::NEG_INFINITY =
 f32(__private::negative_infinity<float>());

inline constexpr f32 f32::consts::E =
    f32(2.718281828459045235360287471352662f);
inline constexpr f32 f32::consts::FRAC_1_PI =
    f32(0.318309886183790671537767526745028f);
inline constexpr f32 f32::consts::FRAC_1_SQRT_2 =
    f32(0.7071067811865476f);
inline constexpr f32 f32::consts::FRAC_2_PI =
    f32(0.6366197723675814f);
inline constexpr f32 f32::consts::FRAC_2_SQRT_PI =
    f32(1.1283791670955126f);
inline constexpr f32 f32::consts::FRAC_PI_2 =
    f32(1.5707963267948966f);
inline constexpr f32 f32::consts::FRAC_PI_3 =
    f32(1.0471975511965979f);
inline constexpr f32 f32::consts::FRAC_PI_4 =
    f32(0.7853981633974483f);
inline constexpr f32 f32::consts::FRAC_PI_6 =
    f32(0.5235987755982989f);
inline constexpr f32 f32::consts::FRAC_PI_8 =
    f32(0.39269908169872414f);
inline constexpr f32 f32::consts::LN_2 =
    f32(0.693147180559945309417232121458176f);
inline constexpr f32 f32::consts::LN_10 =
    f32(2.302585092994045684017991454684364f);
inline constexpr f32 f32::consts::LOG2_10 =
    f32(3.321928094887362f);
inline constexpr f32 f32::consts::LOG2_E =
    f32(1.4426950408889634f);
inline constexpr f32 f32::consts::LOG10_2 =
    f32(0.3010299956639812f);
inline constexpr f32 f32::consts::LOG10_E =
    f32(0.4342944819032518f);
inline constexpr f32 f32::consts::PI =
    f32(3.141592653589793238462643383279502f);
inline constexpr f32 f32::consts::SQRT_2 =
    f32(1.414213562373095048801688724209698f);
inline constexpr f32 f32::consts::TAU =
    f32(6.283185307179586f);

struct [[clang::trivial_abi]] f64 final {

double primitive_value = double{0.0};

static const double MIN_PRIMITIVE;

static const double MAX_PRIMITIVE;

static const f64 MIN;

static const f64 MAX;

static const u32 RADIX;

static const u32 MANTISSA_DIGITS;

static const u32 DIGITS;

static const f64 EPSILON;

static const f64 MIN_POSITIVE;

static const i32 MIN_EXP;

static const i32 MAX_EXP;

static const i32 MIN_10_EXP;

static const i32 MAX_10_EXP;

static const f64 NAN;

static const f64 INFINITY;

static const f64 NEG_INFINITY;

struct consts {

static const f64 E;

static const f64 FRAC_1_PI;

static const f64 FRAC_1_SQRT_2;

static const f64 FRAC_2_PI;

static const f64 FRAC_2_SQRT_PI;

static const f64 FRAC_PI_2;

static const f64 FRAC_PI_3;

static const f64 FRAC_PI_4;

static const f64 FRAC_PI_6;

static const f64 FRAC_PI_8;

static const f64 LN_2;

static const f64 LN_10;

static const f64 LOG2_10;

static const f64 LOG2_E;

static const f64 LOG10_2;

static const f64 LOG10_E;

static const f64 PI;

static const f64 SQRT_2;

static const f64 TAU;
};

constexpr inline f64() noexcept = default;

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<double>())
constexpr inline f64(F v) noexcept : primitive_value(v.primitive_value) {}

template <PrimitiveFloat P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<double>())
constexpr inline f64(P v) noexcept : primitive_value(v) {}

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<double>())
__attribute__((pure)) static constexpr f64 from(F f) noexcept {
 return f64(f);
}

template <PrimitiveFloat F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<double>())
__attribute__((pure)) static constexpr f64 from(F f) noexcept {
 return f64(f);
}

template <Float F>
 requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<double>())
constexpr inline f64& operator=(F v) noexcept {
 primitive_value = v.primitive_value;
 return *this;
}

template <PrimitiveFloat P>
 requires(::sus::mem::size_of() <= ::sus::mem::size_of<double>())
constexpr inline f64& operator=(P v) noexcept {
 primitive_value = v;
 return *this;
}

static constexpr f64 from_sum(::sus::iter::Iterator<f64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = f64(double{0u});
 for (f64 i : ::sus::move(it)) p += i;
 return p;
}

static constexpr f64 from_product(
 ::sus::iter::Iterator<f64> auto&& it) noexcept
 requires(::sus::mem::IsMoveRef<decltype(it)>)
{
 auto p = f64(double{1u});
 for (f64 i : ::sus::move(it)) p *= i;
 return p;
}

template <PrimitiveFloat U>
 requires(::sus::mem::size_of() >= ::sus::mem::size_of<double>())
__attribute__((pure)) constexpr inline operator U() const noexcept {
 return primitive_value;
}

__attribute__((pure)) constexpr double* as_mut_ptr() & noexcept {
  return &primitive_value;
}

__attribute__((pure)) constexpr const double* as_ptr() const& noexcept {
  return &primitive_value;
}
__attribute__((pure)) constexpr const double* as_ptr() && noexcept = delete;

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f64 l, f64 r) noexcept {
 return (l.primitive_value <=> r.primitive_value) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f64 l, Float auto r) noexcept {
 return (l.primitive_value <=> r.primitive_value) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline bool operator==(
 f64 l, PrimitiveFloat auto r) noexcept {
 return (l.primitive_value <=> r) == 0;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f64 l, f64 r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f64 l, Float auto r) noexcept {
 return l.primitive_value <=> r.primitive_value;
}

[[nodiscard]] __attribute__((const)) friend constexpr inline std::partial_ordering
operator<=>(f64 l, PrimitiveFloat auto r) noexcept {
 return l.primitive_value <=> r;
}

__attribute__((pure)) constexpr std::weak_ordering total_cmp(f64 other) const& noexcept {
  return __private::float_strong_ordering(primitive_value,
                                          other.primitive_value);
}

__attribute__((pure)) constexpr inline f64 operator-() const {
  return f64(-primitive_value);
}

[[nodiscard]] __attribute__((pure)) friend constexpr inline f64 operator+(
    f64 l, f64 r) noexcept {
  return l.primitive_value + r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator+(
 f64 l, U r) noexcept {
 return l + f64(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator+(
 U l, f64 r) noexcept {
 return f64(l) + r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator+(f64 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator+(U l, f64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f64 operator-(
    f64 l, f64 r) noexcept {
  return l.primitive_value - r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator-(
 f64 l, U r) noexcept {
 return l - f64(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator-(
 U l, f64 r) noexcept {
 return f64(l) - r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator-(f64 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator-(U l, f64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f64 operator*(
    f64 l, f64 r) noexcept {
  return l.primitive_value * r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator*(
 f64 l, U r) noexcept {
 return l * f64(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator*(
 U l, f64 r) noexcept {
 return f64(l) * r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator*(f64 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator*(U l, f64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f64 operator/(
    f64 l, f64 r) noexcept {
  return l.primitive_value / r.primitive_value;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator/(
 f64 l, U r) noexcept {
 return l / f64(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator/(
 U l, f64 r) noexcept {
 return f64(l) / r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator/(f64 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator/(U l, f64 r) noexcept = delete;

[[nodiscard]] __attribute__((pure)) friend constexpr inline f64 operator%(
    f64 l, f64 r) noexcept {
  const auto x = l.primitive_value;
  const auto y = r.primitive_value;
  return x - __private::truncate_float(x / y) * y;
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator%(
 f64 l, U r) noexcept {
 return l % f64(r);
}

template <PrimitiveFloat U>
 requires(std::convertible_to<U, f64>)
[[nodiscard]] __attribute__((const)) friend constexpr inline f64 operator%(
 U l, f64 r) noexcept {
 return f64(l) % r;
}

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator%(f64 l, U r) noexcept = delete;

template <PrimitiveFloat U>
 requires(!std::convertible_to<U, f64>)
friend constexpr inline f64 operator%(U l, f64 r) noexcept = delete;

constexpr inline void operator+=(f64 r) & noexcept {
  primitive_value += r.primitive_value;
}

constexpr inline void operator-=(f64 r) & noexcept {
  primitive_value -= r.primitive_value;
}

constexpr inline void operator*=(f64 r) & noexcept {
  primitive_value *= r.primitive_value;
}

constexpr inline void operator/=(f64 r) & noexcept {
  primitive_value /= r.primitive_value;
}

constexpr inline void operator%=(f64 r) & noexcept {
  const auto x = primitive_value;
  const auto y = r.primitive_value;
  primitive_value = x - __private::truncate_float(x / y) * y;
}

__attribute__((pure)) inline f64 abs() const& noexcept {
 return __private::into_float(
 __private::into_unsigned_integer(primitive_value) &
 ~__private::high_bit<double>());
}

__attribute__((pure)) inline f64 acos() const& noexcept {
 if (primitive_value < double{-1} || primitive_value > double{1})
 [[unlikely]]
 return NAN;

return static_cast<double>(::acos(primitive_value));
}

__attribute__((pure)) inline f64 acosh() const& noexcept {
 if (primitive_value < double{-1}) [[unlikely]]
 return NAN;

return static_cast<double>(::acosh(primitive_value));
}

__attribute__((pure)) inline f64 asin() const& noexcept {
 if (primitive_value < double{-1} || primitive_value > double{1})
 [[unlikely]]
 return NAN;

return static_cast<double>(::asin(primitive_value));
}

__attribute__((pure)) inline f64 asinh() const& noexcept {
 if (primitive_value < double{-1}) [[unlikely]]
 return NAN;

return static_cast<double>(::asinh(primitive_value));
}

__attribute__((pure)) inline f64 atan() const& noexcept {

return static_cast<double>(::atan(primitive_value));
}

__attribute__((pure)) inline f64 atan2(f64 other) const& noexcept {

return static_cast<double>(
 ::atan2(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f64 atanh() const& noexcept {

return static_cast<double>(::atanh(primitive_value));
}

__attribute__((pure)) inline f64 cbrt() const& noexcept {

return static_cast<double>(::cbrt(primitive_value));
}

__attribute__((pure)) inline f64 ceil() const& noexcept {

return static_cast<double>(::ceil(primitive_value));
}

__attribute__((pure)) inline f64 copysign(f64 sign) const& noexcept {

return static_cast<double>(
 ::copysign(primitive_value, sign.primitive_value));
}

__attribute__((pure)) inline f64 cos() const& noexcept {

return static_cast<double>(::cos(primitive_value));
}

__attribute__((pure)) inline f64 cosh() const& noexcept {

return static_cast<double>(::cosh(primitive_value));
}

__attribute__((pure)) inline f64 exp() const& noexcept {

return static_cast<double>(::exp(primitive_value));
}

__attribute__((pure)) inline f64 exp2() const& noexcept {

return static_cast<double>(::exp2(primitive_value));
}

__attribute__((pure)) inline f64 exp_m1() const& noexcept {

return static_cast<double>(::expm1(primitive_value));
}

__attribute__((pure)) inline f64 floor() const& noexcept {

return static_cast<double>(::floor(primitive_value));
}

__attribute__((pure)) inline f64 hypot(f64 other) const& noexcept {

return static_cast<double>(
 ::hypot(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f64 ln() const& noexcept {

return static_cast<double>(::log(primitive_value));
}

__attribute__((pure)) inline f64 ln_1p() const& noexcept {

return static_cast<double>(::log1p(primitive_value));
}

__attribute__((pure)) inline f64 log10() const& noexcept {

return static_cast<double>(::log10(primitive_value));
}

__attribute__((pure)) inline f64 log2() const& noexcept {

return static_cast<double>(::log2(primitive_value));
}

__attribute__((pure)) inline f64 log(f64 base) const& noexcept {
  return ln() / base.ln();
}

__attribute__((pure)) inline f64 max(f64 other) const& noexcept {

return static_cast<double>(
 ::fmax(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f64 min(f64 other) const& noexcept {

return static_cast<double>(
 ::fmin(primitive_value, other.primitive_value));
}

__attribute__((pure)) inline f64 mul_add(f64 a, f64 b) const& noexcept {

return static_cast<double>(
 ::fma(primitive_value, a.primitive_value, b.primitive_value));
}

__attribute__((pure)) inline f64 next_toward(f64 toward) const& noexcept {
  return __private::next_toward(primitive_value, toward.primitive_value);
}

__attribute__((pure)) inline f64 powf(f64 n) const& noexcept {

return static_cast<double>(::pow(primitive_value, n.primitive_value));
}

__attribute__((pure)) inline f64 powi(i32 n) const& noexcept {

return static_cast<double>(
 ::pow(primitive_value, int{n.primitive_value}));
}

__attribute__((pure)) inline f64 recip() const& noexcept {
  return double{1} / primitive_value;
}

__attribute__((pure)) inline f64 round() const& noexcept {
  return __private::float_round(primitive_value);
}

__attribute__((pure)) inline f64 round_ties() const& noexcept {
  return __private::float_round_ties_by_mode(primitive_value);
}

__attribute__((pure)) inline i8 round_to_i8() const& noexcept {
 return __private::float_round_to<decltype(i8::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i16 round_to_i16() const& noexcept {
 return __private::float_round_to<decltype(i16::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i32 round_to_i32() const& noexcept {
 return __private::float_round_to<decltype(i32::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline i64 round_to_i64() const& noexcept {
 return __private::float_round_to<decltype(i64::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline isize round_to_isize() const& noexcept {
 return __private::float_round_to<decltype(isize::MAX_PRIMITIVE)>(
 primitive_value);
}

__attribute__((pure)) inline f64 signum() const& noexcept {

return __private::float_signum(primitive_value);
}

__attribute__((pure)) inline f64 sin() const& noexcept {

return static_cast<double>(::sin(primitive_value));
}

__attribute__((pure)) inline f64 sinh() const& noexcept {

return static_cast<double>(::sinh(primitive_value));
}

__attribute__((pure)) inline f64 sqrt() const& noexcept {
 if (primitive_value < -double{0}) [[unlikely]]
 return NAN;

return static_cast<double>(::sqrt(primitive_value));
}

__attribute__((pure)) inline f64 tan() const& noexcept {

return static_cast<double>(::tan(primitive_value));
}

__attribute__((pure)) inline f64 tanh() const& noexcept {

return static_cast<double>(::tanh(primitive_value));
}

__attribute__((pure)) inline f64 fract() const& noexcept {
  return primitive_value - __private::truncate_float(primitive_value);
}

__attribute__((pure)) inline f64 trunc() const& noexcept {
  return __private::truncate_float(primitive_value);
}

__attribute__((pure)) inline f64 to_degrees() const& noexcept {

constexpr auto PIS_IN_180 = double{57.2957795130823208767981548141051703};
  return primitive_value * PIS_IN_180;
}

__attribute__((pure)) inline f64 to_radians() const& noexcept {
  return primitive_value * (consts::PI.primitive_value / double{180});
}

__attribute__((pure)) static f64 from_bits(u64 v) noexcept {
 return std::bit_cast<f64>(v);
}

__attribute__((pure)) constexpr inline u64 to_bits() const& noexcept {
 return std::bit_cast<decltype(u64::primitive_value)>(primitive_value);
}