libdpf/include/dpf/modint.hpp

/// @file dpf/modint.hpp
/// @brief defines the `dpf::modint` class and associated helpers
/// @details A `dpf::modint` is a thin wrapper around some primitive integral
///          type. The underlying value is reduced modulo `2^Nbits` only when the
///          underlying value is read; arithmetic operations have no overhead
///          relative to native operations on the underlying type.
/// @author Ryan Henry <ryan.henry@ucalgary.ca>
/// @copyright Copyright (c) 2019-2024 Ryan Henry and [others](@ref authors)
/// @license Released under a GNU General Public v2.0 (GPLv2) license;
///          see [LICENSE.md](@ref license) for details.

#ifndef LIBDPF_INCLUDE_DPF_MODINT_HPP__
#define LIBDPF_INCLUDE_DPF_MODINT_HPP__

#include <cstddef>
#include <cstring>
#include <cmath>
#include <type_traits>
#include <functional>
#include <string>
#include <memory>
#include <limits>
#include <ostream>
#include <istream>

#include "hedley/hedley.h"
#include "portable-snippets/exact-int/exact-int.h"

#include "dpf/utils.hpp"
#include "dpf/literals.hpp"

namespace dpf
{

/// @brief represents an unsigned integer modulo `2^Nbits` for small values of `Nbits`
/// @tparam Nbits width in bits
template <std::size_t Nbits>
class modint
{
  public:
    /// @brief the primitive integral type used to represent the `modint`
    using integral_type = dpf::utils::nonvoid_integral_type_from_bitlength_t<Nbits>;

    static constexpr std::size_t num_bits = Nbits;
    static constexpr bool dpf_modint = true;

    /// @brief construct the `modint`
    /// @{

    /// @brief value constructor
    /// @details Constructs a `modint` whose value is initialized to the
    ///          smallest nonnegative integer that is congruent to `value`
    ///          modulo `2^Nbits`.
    /// @param value the value to initialize with
    HEDLEY_ALWAYS_INLINE
    // cppcheck-suppress noExplicitConstructor
    constexpr modint(integral_type value)  // NOLINT(runtime/explicit)
        : val{value}
    { }

    /// @brief default constructor
    /// @details Constructs a `modint` whose value is initialized to `0`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint() noexcept = default;

    /// @brief copy constructor
    /// @details Constructs the `modint` with a value copied from another
    ///          `modint`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint(const modint &) noexcept = default;

    /// @brief move constructor
    /// @details Constructs the `modint` from another `modint` using move
    ///          semantics.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint(modint &&) noexcept = default;

    /// @}

    /// @brief assign the `modint`
    /// @return `*this`
    /// @{

    /// @brief value assignment
    /// @details Sets the `modint` equal to the smallest nonnegative integer
    ///          that is congruent to `value` modulo `2^Nbits`.
    /// @param value the value to assign with
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator=(integral_type value)
    {
        this->val = value;
        return *this;
    }

    /// @brief copy assignment
    /// @details Assigns the `modint` with a value copied from another
    ///          `modint`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator=(const modint &) noexcept = default;

    /// @brief move assignment
    /// @details Assigns the `modint` from another `modint` using move
    ///          semantics.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator=(modint &&) noexcept = default;

    /// @}

    ~modint() = default;

    /// @brief addition operator
    /// @param rhs the other addend
    /// @return the sum
    /// @{

    /// @details Performs addition with an `integral_type`.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator+(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val+rhs)};
    }

    /// @details Performs addition with another `modint`.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator+(modint rhs) const noexcept
    {
        return this->operator+(rhs.val);
    }

    /// @}

    /// @brief addition-assignment operator
    /// @param rhs the other addend
    /// @return `*this`
    /// @{

    /// @details Adds an `integral_type` to this `modint`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator+=(integral_type rhs) noexcept
    {
        this->val += rhs;
        return *this;
    }

    /// @details Adds another `modint` to this one.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator+=(modint rhs) noexcept
    {
        return this->operator+=(rhs.val);
    }

    /// @}

    /// @brief increment operator
    /// @{

    /// @brief pre-increment operator
    /// @details Increments this `modint` and returns a reference to the
    ///          result.
    /// @return `*this`
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator++() noexcept
    {
        return this->operator+=(integral_type{1});
    }

    /// @brief post-increment operator
    /// @details Creates a copy of this `modint`, and then increments this
    ///          `modint` and returns the copy from before the increment.
    /// @return `*this`
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator++(int) noexcept
    {
        auto ret = *this;
        this->operator++();
        return ret;
    }

    /// @}

    /// @brief unary negation
    /// @details Returns the additive inverse modulo `2^Nbits` (two's
    ///          complement on the underlying word). Required by
    ///          `grotto::for_each_offset`, which computes `-offset`.
    /// @return unary negation
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator-() const noexcept
    {
        return modint{static_cast<integral_type>(-this->val)};
    }

    /// @brief subtraction operator
    /// @param rhs the subtrahend
    /// @return the difference
    /// @{

    /// @details Performs subtraction by an `integral_type`.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator-(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val-rhs)};
    }

    /// @details Performs subtraction by another `modint`.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator-(modint rhs) const noexcept
    {
        return this->operator-(rhs.val);
    }

    /// @}

    /// @brief subtraction-assignment operator
    /// @param rhs the subtrahend
    /// @return `*this`
    /// @{

    /// @details Subtracts an `integral_type` from this `modint`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator-=(integral_type rhs) noexcept
    {
        this->val -= rhs;
        return *this;
    }

    /// @details Subtracts another `modint` from this one.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator-=(modint rhs) noexcept
    {
        return this->operator-=(rhs.val);
    }

    /// @}

    /// @brief decrement operator
    /// @{

    /// @brief pre-decrement operator
    /// @details Decrements this `modint` and returns a reference to the
    ///          result.
    /// @return `*this`
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator--() noexcept
    {
        return this->operator-=(integral_type{1});
    }

    /// @brief post-decrement operator
    /// @details Creates a copy of this `modint`, and then decrements this
    ///          `modint` and returns the copy from before the decrement.
    /// @return `*this`
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator--(int) noexcept
    {
        auto ret = *this;
        this->operator--();
        return ret;
    }

    /// @}

    /// @brief bitwise-left-shift operator
    /// @details Returns a `modint` whose value is obtained by shifting this
    ///          one by `shift_amount` bits to the left. The value of `a<<b`
    ///          is therefore a `modint` congruent to `a * 2^b` modulo `2^Nbits`.
    /// @param shift_amount the number of bits to shift by
    /// @return bitwise-left-shift operator
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator<<(std::size_t shift_amount) const noexcept
    {
        if (shift_amount >= Nbits)
            return modint{integral_type{0}};
        // Reduce first: an unreduced limb shifted by less than Nbits can
        // still leave the modulus, and a shift of the limb width is UB.
        return modint{static_cast<integral_type>(this->reduced_value() << shift_amount)};
    }

    /// @brief bitwise-left-shift-assignment operator
    /// @details Left-shifts this `modint` by `shift_amount` bits to the left
    ///          and returns a reference to the result. Upon invoking `a<<=b`,
    ///          `a` is congruent to `a * 2^b` modulo `2^Nbits`.
    /// @param shift_amount the number of bits to shift by
    /// @return `*this`
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator<<=(std::size_t shift_amount) noexcept
    {
        if (shift_amount >= Nbits)
            this->val = integral_type{0};
        else
            this->val = static_cast<integral_type>(this->reduced_value() << shift_amount);
        return *this;
    }

    /// @brief bitwise-right-shift operator
    /// @details Returns a `modint` whose value is obtained by shifting this
    ///          one by `shift_amount` bits to the right. The value of `a>>b`
    ///          is therefore a `modint` equal to the integer part of `a/2^b`.
    /// @param shift_amount the number of bits to shift by
    /// @return bitwise-right-shift operator
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator>>(std::size_t shift_amount) const noexcept
    {
        if (shift_amount >= Nbits)
            return modint{integral_type{0}};
        return modint{static_cast<integral_type>(this->reduced_value() >> shift_amount)};
    }

    /// @brief bitwise-right-shift-assignment operator
    /// @details Right-shifts this `modint` by `shift_amount` bits to the
    ///          right and returns a reference to the result. Upon invoking
    ///          `a>>=b`, `a` is equal to the integer part of `a/2^b`.
    /// @param shift_amount the number of bits to shift by
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator>>=(std::size_t shift_amount) noexcept
    {
        if (shift_amount >= Nbits)
            this->val = integral_type{0};
        else
            this->val = this->reduced_value() >> shift_amount;
        return *this;
    }

    /// @brief Integer division of the reduced values.
    /// @param rhs the right-hand operand
    /// @return Integer division of the reduced values
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator/(modint rhs) const noexcept
    {
        return modint{static_cast<integral_type>(
            this->reduced_value() / rhs.reduced_value())};
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator%(std::size_t modulus) const noexcept
    {
        return modint{static_cast<integral_type>(this->reduced_value() % modulus)};
    }

    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator%=(std::size_t modulus) noexcept
    {
        this->val = this->reduced_value() % modulus;
        return *this;
    }

    /// @brief multiplication operator
    /// @param rhs the other multiplicand
    /// @return the product
    /// @{

    /// @brief Multiplies this `modint` with an `integral_type`.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator*(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val*rhs)};
    }

    /// @brief Multiplies another `modint` with this one.
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator*(modint rhs) const noexcept
    {
        return this->operator*(rhs.val);
    }

    /// @}

    /// @brief multiplication-assignment operator
    /// @param rhs the other multiplicand
    /// @return `*this`
    /// @{

    /// @details Multiplies an `integral_type` into this `modint`.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator*=(integral_type rhs) noexcept
    {
        this->val *= rhs;
        return *this;
    }

    /// @details Multiplies another `modint` into this one.
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator*=(modint rhs) noexcept
    {
        return this->operator*=(rhs.val);
    }

    /// @}

    /// @brief bitwise-logical-AND operator
    /// @{
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator&(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val & rhs)};
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator&(modint rhs) const noexcept
    {
        return this->operator&(rhs.val);
    }
    /// @}

    /// @brief bitwise-logical-AND-assignment operator
    /// @{
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator&=(integral_type rhs) noexcept
    {
        this->val &= rhs;
        return *this;
    }

    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator&=(modint rhs) noexcept
    {
        return this->operator&=(rhs.val);
    }
    /// @}

    /// @brief bitwise logical OR operator
    /// @{
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator|(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val | rhs)};
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator|(modint rhs) const noexcept
    {
        return this->operator|(rhs.val);
    }
    /// @}

    /// @brief bitwise-logical-OR-assignment operator
    /// @{
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator|=(integral_type rhs) noexcept
    {
        this->val |= rhs;
        return *this;
    }

    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator|=(modint rhs) noexcept
    {
        return this->operator|=(rhs.val);
    }
    /// @}

    /// @brief bitwise logical XOR operator
    /// @{
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator^(integral_type rhs) const noexcept
    {
        return modint{static_cast<integral_type>(this->val^rhs)};
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator^(modint rhs) const noexcept
    {
        return this->operator^(rhs.val);
    }
    /// @}

    /// @brief bitwise-logical-XOR-assignment operator
    /// @{
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator^=(integral_type rhs) noexcept
    {
        this->val ^= rhs;
        return *this;
    }

    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint & operator^=(modint rhs) noexcept
    {
        return this->operator^=(rhs.val);
    }
    /// @}

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr modint operator~() const noexcept
    {
        return modint{static_cast<integral_type>(~this->val)};
    }

    /// @brief convert this `modint` to the equivalent `integeral_type`
    /// @return the returned `operator`
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr explicit operator integral_type() const noexcept
    {
        return this->reduced_value();
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr explicit operator bool() const noexcept
    {
        return static_cast<bool>(this->reduced_value());
    }

    template <std::size_t NbitsNew>
    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr explicit operator modint<NbitsNew>() const noexcept
    {
        return modint<NbitsNew>{static_cast<typename modint<NbitsNew>::integral_type>(this->reduced_value())};
    }

    HEDLEY_PURE
    HEDLEY_NO_THROW
    HEDLEY_ALWAYS_INLINE
    constexpr integral_type data() const noexcept
    {
        return this->val;
    }

    template <typename CharT,
              typename Traits = std::char_traits<CharT>,
              typename Allocator = std::allocator<CharT>>
    friend std::basic_ostream<CharT, Traits> &
    operator<<(std::basic_ostream<CharT, Traits> & os,
        const modint & i)
    {
        const auto raw = i.reduced_value();
        using word = std::remove_cv_t<std::decay_t<decltype(raw)>>;
        if constexpr (std::is_same_v<word, unsigned __int128>
            || std::is_same_v<word, __int128>)
        {
            if (raw == 0)
                return os << CharT('0');
            CharT buf[40];
            int n = 0;
            auto v = raw;
            while (v != 0)
            {
                buf[n++] = static_cast<CharT>('0' + static_cast<int>(v % 10));
                v /= 10;
            }
            while (n > 0)
                os << buf[--n];
            return os;
        }
        else if constexpr (std::is_integral_v<word>)
            return os << raw;
        else
        {
            unsigned char bytes[sizeof(word)];
            std::memcpy(bytes, &raw, sizeof(word));
            os << "0x";
            bool started = false;
            constexpr char hex[] = "0123456789abcdef";
            for (int b = static_cast<int>(sizeof(word)) - 1; b >= 0; --b)
            {
                if (!started && bytes[static_cast<std::size_t>(b)] == 0 && b != 0)
                    continue;
                started = true;
                const auto byte = bytes[static_cast<std::size_t>(b)];
                os << hex[byte >> 4] << hex[byte & 0x0f];
            }
            return os;
        }
    }

    template <typename CharT,
              typename Traits = std::char_traits<CharT>,
              typename Allocator = std::allocator<CharT>>
    friend std::basic_istream<CharT, Traits> &
    operator>>(std::basic_istream<CharT, Traits> & is,
        modint & i)
    {
        // Extract a number, not a character. `operator>>` on `unsigned char`
        // reads one character, which is the wrong operation for a `modint`.
        if constexpr (sizeof(integral_type) <= sizeof(unsigned long long))
        {
            unsigned long long tmp = 0;
            if (is >> tmp)
                i = static_cast<integral_type>(tmp);
        }
        else
        {
            integral_type tmp{};
            if (is >> tmp)
                i = tmp;
        }
        return is;
    }

    constexpr integral_type reduced_value() const
    {
        return val & modulo_mask;
    }

  private:
    /// @brief bitmask used for performing reductions modulo `2^Nbits`
    static constexpr integral_type modulo_mask = static_cast<integral_type>(~integral_type{0}) >> utils::bitlength_of_v<integral_type> - Nbits;

    /// @brief The `integral_type` used to represent this `modint`
    integral_type val;

    friend struct utils::mod_pow_2<modint>;
};

/// @brief Multiplies a `modint<Nbits>` with an `modint::integral_type`.
/// @tparam Nbits width in bits
/// @param lhs the `integral_type` multiplicand
/// @param rhs the `modint` multiplicand
/// @return Multiplies a `modint<Nbits>` with an `modint::integral_type`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr modint<Nbits> operator*(typename modint<Nbits>::integral_type lhs,
    modint<Nbits> rhs) noexcept
{
    return rhs * lhs;
}

/// @brief Compare two `modint<Nbits>`s as if they were regular integers
/// @tparam Nbits width in bits
/// @param lhs the left-hand operand
/// @param rhs the right-hand operand
/// @{

/// @brief less-than operator
/// @return `true` when `lhs < rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator<(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        < static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @brief less-than-or-equal-to operator
/// @return `true` when `lhs <= rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator<=(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        <= static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @brief greater-than operator
/// @return `true` when `lhs > rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator>(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        > static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @brief greater-than-or-equal-to operator
/// @return `true` when `lhs >= rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator>=(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        >= static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @brief equality operator
/// @return `true` when `lhs == rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator==(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        == static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @brief inequality operator
/// @return `true` when `lhs != rhs`
template <std::size_t Nbits>
HEDLEY_CONST
HEDLEY_ALWAYS_INLINE
HEDLEY_NO_THROW
constexpr bool operator!=(modint<Nbits> lhs, modint<Nbits> rhs) noexcept
{
    return static_cast<typename modint<Nbits>::integral_type>(lhs)
        != static_cast<typename modint<Nbits>::integral_type>(rhs);
}

/// @}

namespace utils
{

template <std::size_t N>
struct make_unsigned<dpf::modint<N>> { using type = dpf::modint<N>; };

template <std::size_t Nbits>
struct bitlength_of<dpf::modint<Nbits>>
  : public std::integral_constant<std::size_t, Nbits> { };

template <std::size_t Nbits>
struct msb_of<dpf::modint<Nbits>>
{
    static constexpr dpf::modint<Nbits> value
        = dpf::modint<Nbits>{1} << bitlength_of_v<dpf::modint<Nbits>> - 1ul;
};

template <std::size_t Nbits>
struct countl_zero_symmetric_difference<dpf::modint<Nbits>>
{
    using T = dpf::modint<Nbits>;
    HEDLEY_NO_THROW
    HEDLEY_CONST
    HEDLEY_ALWAYS_INLINE
    constexpr std::size_t operator()(T lhs, T rhs) const noexcept
    {
        using T = typename dpf::modint<Nbits>::integral_type;
        constexpr auto xor_op = std::bit_xor<T>{};
        constexpr auto adjust = utils::bitlength_of_v<T> - Nbits;
        auto diff = xor_op(static_cast<T>(lhs), static_cast<T>(rhs));
        if (!diff)
        {
            return Nbits;
        }

        if constexpr (std::is_same_v<T, simde_uint128>)
        {
            auto diff_hi = static_cast<psnip_uint64_t>(diff >> 64);
            auto diff_lo = static_cast<psnip_uint64_t>(diff);

            return diff_hi ? utils::clz(diff_hi)-adjust : 64+utils::clz(diff_lo)-adjust;
        }
        else if constexpr (std::is_same_v<T, uint256_t>)
        {
            return utils::clz(diff) - adjust;
        }
        else
        {
            return utils::clz(diff)-adjust;
        }
    }
};

template <std::size_t Nbits>
struct mod_pow_2<dpf::modint<Nbits>>
{
    using T = dpf::modint<Nbits>;
    static constexpr auto mod = mod_pow_2<typename T::integral_type>{};
    HEDLEY_NO_THROW
    std::size_t operator()(T val, std::size_t n) const noexcept
    {
        return mod(val.val, n);
    }
};

}  // namespace utils

namespace modints
{

// 1--9
using modint1_t = dpf::modint<1>;
using modint2_t = dpf::modint<2>;
using modint3_t = dpf::modint<3>;
using modint4_t = dpf::modint<4>;
using modint5_t = dpf::modint<5>;
using modint6_t = dpf::modint<6>;
using modint7_t = dpf::modint<7>;
using modint8_t = dpf::modint<8>;
using modint9_t = dpf::modint<9>;
// 10--19
using modint10_t = dpf::modint<10>;
using modint11_t = dpf::modint<11>;
using modint12_t = dpf::modint<12>;
using modint13_t = dpf::modint<13>;
using modint14_t = dpf::modint<14>;
using modint15_t = dpf::modint<15>;
using modint16_t = dpf::modint<16>;
using modint17_t = dpf::modint<17>;
using modint18_t = dpf::modint<18>;
using modint19_t = dpf::modint<19>;
// 20--29
using modint20_t = dpf::modint<20>;
using modint21_t = dpf::modint<21>;
using modint22_t = dpf::modint<22>;
using modint23_t = dpf::modint<23>;
using modint24_t = dpf::modint<24>;
using modint25_t = dpf::modint<25>;
using modint26_t = dpf::modint<26>;
using modint27_t = dpf::modint<27>;
using modint28_t = dpf::modint<28>;
using modint29_t = dpf::modint<29>;
// 30--39
using modint30_t = dpf::modint<30>;
using modint31_t = dpf::modint<31>;
using modint32_t = dpf::modint<32>;
using modint33_t = dpf::modint<33>;
using modint34_t = dpf::modint<34>;
using modint35_t = dpf::modint<35>;
using modint36_t = dpf::modint<36>;
using modint37_t = dpf::modint<37>;
using modint38_t = dpf::modint<38>;
using modint39_t = dpf::modint<39>;
// 40--49
using modint40_t = dpf::modint<40>;
using modint41_t = dpf::modint<41>;
using modint42_t = dpf::modint<42>;
using modint43_t = dpf::modint<43>;
using modint44_t = dpf::modint<44>;
using modint45_t = dpf::modint<45>;
using modint46_t = dpf::modint<46>;
using modint47_t = dpf::modint<47>;
using modint48_t = dpf::modint<48>;
using modint49_t = dpf::modint<49>;
// 50--59
using modint50_t = dpf::modint<50>;
using modint51_t = dpf::modint<51>;
using modint52_t = dpf::modint<52>;
using modint53_t = dpf::modint<53>;
using modint54_t = dpf::modint<54>;
using modint55_t = dpf::modint<55>;
using modint56_t = dpf::modint<56>;
using modint57_t = dpf::modint<57>;
using modint58_t = dpf::modint<58>;
using modint59_t = dpf::modint<59>;
// 60--69
using modint60_t = dpf::modint<60>;
using modint61_t = dpf::modint<61>;
using modint62_t = dpf::modint<62>;
using modint63_t = dpf::modint<63>;
using modint64_t = dpf::modint<64>;
using modint65_t = dpf::modint<65>;
using modint66_t = dpf::modint<66>;
using modint67_t = dpf::modint<67>;
using modint68_t = dpf::modint<68>;
using modint69_t = dpf::modint<69>;
// 70--79
using modint70_t = dpf::modint<70>;
using modint71_t = dpf::modint<71>;
using modint72_t = dpf::modint<72>;
using modint73_t = dpf::modint<73>;
using modint74_t = dpf::modint<74>;
using modint75_t = dpf::modint<75>;
using modint76_t = dpf::modint<76>;
using modint77_t = dpf::modint<77>;
using modint78_t = dpf::modint<78>;
using modint79_t = dpf::modint<79>;
// 80--89
using modint80_t = dpf::modint<80>;
using modint81_t = dpf::modint<81>;
using modint82_t = dpf::modint<82>;
using modint83_t = dpf::modint<83>;
using modint84_t = dpf::modint<84>;
using modint85_t = dpf::modint<85>;
using modint86_t = dpf::modint<86>;
using modint87_t = dpf::modint<87>;
using modint88_t = dpf::modint<88>;
using modint89_t = dpf::modint<89>;
using modint90_t = dpf::modint<90>;
// 90--99
using modint91_t = dpf::modint<91>;
using modint92_t = dpf::modint<92>;
using modint93_t = dpf::modint<93>;
using modint94_t = dpf::modint<94>;
using modint95_t = dpf::modint<95>;
using modint96_t = dpf::modint<96>;
using modint97_t = dpf::modint<97>;
using modint98_t = dpf::modint<98>;
using modint99_t = dpf::modint<99>;
// 100--109
using modint100_t = dpf::modint<100>;
using modint101_t = dpf::modint<101>;
using modint102_t = dpf::modint<102>;
using modint103_t = dpf::modint<103>;
using modint104_t = dpf::modint<104>;
using modint105_t = dpf::modint<105>;
using modint106_t = dpf::modint<106>;
using modint107_t = dpf::modint<107>;
using modint108_t = dpf::modint<108>;
using modint109_t = dpf::modint<109>;
// 110--119
using modint110_t = dpf::modint<110>;
using modint111_t = dpf::modint<111>;
using modint112_t = dpf::modint<112>;
using modint113_t = dpf::modint<113>;
using modint114_t = dpf::modint<114>;
using modint115_t = dpf::modint<115>;
using modint116_t = dpf::modint<116>;
using modint117_t = dpf::modint<117>;
using modint118_t = dpf::modint<118>;
using modint119_t = dpf::modint<119>;
// 120--129
using modint120_t = dpf::modint<120>;
using modint121_t = dpf::modint<121>;
using modint122_t = dpf::modint<122>;
using modint123_t = dpf::modint<123>;
using modint124_t = dpf::modint<124>;
using modint125_t = dpf::modint<125>;
using modint126_t = dpf::modint<126>;
using modint127_t = dpf::modint<127>;
using modint128_t = dpf::modint<128>;
using modint129_t = dpf::modint<129>;
// 130--139
using modint130_t = dpf::modint<130>;
using modint131_t = dpf::modint<131>;
using modint132_t = dpf::modint<132>;
using modint133_t = dpf::modint<133>;
using modint134_t = dpf::modint<134>;
using modint135_t = dpf::modint<135>;
using modint136_t = dpf::modint<136>;
using modint137_t = dpf::modint<137>;
using modint138_t = dpf::modint<138>;
using modint139_t = dpf::modint<139>;
// 140--149
using modint140_t = dpf::modint<140>;
using modint141_t = dpf::modint<141>;
using modint142_t = dpf::modint<142>;
using modint143_t = dpf::modint<143>;
using modint144_t = dpf::modint<144>;
using modint145_t = dpf::modint<145>;
using modint146_t = dpf::modint<146>;
using modint147_t = dpf::modint<147>;
using modint148_t = dpf::modint<148>;
using modint149_t = dpf::modint<149>;
// 150--159
using modint150_t = dpf::modint<150>;
using modint151_t = dpf::modint<151>;
using modint152_t = dpf::modint<152>;
using modint153_t = dpf::modint<153>;
using modint154_t = dpf::modint<154>;
using modint155_t = dpf::modint<155>;
using modint156_t = dpf::modint<156>;
using modint157_t = dpf::modint<157>;
using modint158_t = dpf::modint<158>;
using modint159_t = dpf::modint<159>;
// 160--169
using modint160_t = dpf::modint<160>;
using modint161_t = dpf::modint<161>;
using modint162_t = dpf::modint<162>;
using modint163_t = dpf::modint<163>;
using modint164_t = dpf::modint<164>;
using modint165_t = dpf::modint<165>;
using modint166_t = dpf::modint<166>;
using modint167_t = dpf::modint<167>;
using modint168_t = dpf::modint<168>;
using modint169_t = dpf::modint<169>;
// 170--179
using modint170_t = dpf::modint<170>;
using modint171_t = dpf::modint<171>;
using modint172_t = dpf::modint<172>;
using modint173_t = dpf::modint<173>;
using modint174_t = dpf::modint<174>;
using modint175_t = dpf::modint<175>;
using modint176_t = dpf::modint<176>;
using modint177_t = dpf::modint<177>;
using modint178_t = dpf::modint<178>;
using modint179_t = dpf::modint<179>;
// 180--189
using modint180_t = dpf::modint<180>;
using modint181_t = dpf::modint<181>;
using modint182_t = dpf::modint<182>;
using modint183_t = dpf::modint<183>;
using modint184_t = dpf::modint<184>;
using modint185_t = dpf::modint<185>;
using modint186_t = dpf::modint<186>;
using modint187_t = dpf::modint<187>;
using modint188_t = dpf::modint<188>;
using modint189_t = dpf::modint<189>;
// 190--199
using modint190_t = dpf::modint<190>;
using modint191_t = dpf::modint<191>;
using modint192_t = dpf::modint<192>;
using modint193_t = dpf::modint<193>;
using modint194_t = dpf::modint<194>;
using modint195_t = dpf::modint<195>;
using modint196_t = dpf::modint<196>;
using modint197_t = dpf::modint<197>;
using modint198_t = dpf::modint<198>;
using modint199_t = dpf::modint<199>;
// 200--209
using modint200_t = dpf::modint<200>;
using modint201_t = dpf::modint<201>;
using modint202_t = dpf::modint<202>;
using modint203_t = dpf::modint<203>;
using modint204_t = dpf::modint<204>;
using modint205_t = dpf::modint<205>;
using modint206_t = dpf::modint<206>;
using modint207_t = dpf::modint<207>;
using modint208_t = dpf::modint<208>;
using modint209_t = dpf::modint<209>;
// 210--219
using modint210_t = dpf::modint<210>;
using modint211_t = dpf::modint<211>;
using modint212_t = dpf::modint<212>;
using modint213_t = dpf::modint<213>;
using modint214_t = dpf::modint<214>;
using modint215_t = dpf::modint<215>;
using modint216_t = dpf::modint<216>;
using modint217_t = dpf::modint<217>;
using modint218_t = dpf::modint<218>;
using modint219_t = dpf::modint<219>;
// 220--229
using modint220_t = dpf::modint<220>;
using modint221_t = dpf::modint<221>;
using modint222_t = dpf::modint<222>;
using modint223_t = dpf::modint<223>;
using modint224_t = dpf::modint<224>;
using modint225_t = dpf::modint<225>;
using modint226_t = dpf::modint<226>;
using modint227_t = dpf::modint<227>;
using modint228_t = dpf::modint<228>;
using modint229_t = dpf::modint<229>;
// 120--239
using modint230_t = dpf::modint<230>;
using modint231_t = dpf::modint<231>;
using modint232_t = dpf::modint<232>;
using modint233_t = dpf::modint<233>;
using modint234_t = dpf::modint<234>;
using modint235_t = dpf::modint<235>;
using modint236_t = dpf::modint<236>;
using modint237_t = dpf::modint<237>;
using modint238_t = dpf::modint<238>;
using modint239_t = dpf::modint<239>;
// 240--249
using modint240_t = dpf::modint<240>;
using modint241_t = dpf::modint<241>;
using modint242_t = dpf::modint<242>;
using modint243_t = dpf::modint<243>;
using modint244_t = dpf::modint<244>;
using modint245_t = dpf::modint<245>;
using modint246_t = dpf::modint<246>;
using modint247_t = dpf::modint<247>;
using modint248_t = dpf::modint<248>;
using modint249_t = dpf::modint<249>;
// 250--256
using modint250_t = dpf::modint<250>;
using modint251_t = dpf::modint<251>;
using modint252_t = dpf::modint<252>;
using modint253_t = dpf::modint<253>;
using modint254_t = dpf::modint<254>;
using modint255_t = dpf::modint<255>;
using modint256_t = dpf::modint<256>;

namespace literals = dpf::literals::modints;

}  // namespace modints

namespace literals
{

namespace modints
{

// 1--9
constexpr static auto operator "" _u1(unsigned long long int x) { return dpf::modints::modint1_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u2(unsigned long long int x) { return dpf::modints::modint2_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u3(unsigned long long int x) { return dpf::modints::modint3_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u4(unsigned long long int x) { return dpf::modints::modint4_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u5(unsigned long long int x) { return dpf::modints::modint5_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u6(unsigned long long int x) { return dpf::modints::modint6_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u7(unsigned long long int x) { return dpf::modints::modint7_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u8(unsigned long long int x) { return dpf::modints::modint8_t{static_cast<psnip_uint8_t>(x)}; }
constexpr static auto operator "" _u9(unsigned long long int x) { return dpf::modints::modint9_t{static_cast<psnip_uint16_t>(x)}; }
// 10--19
constexpr static auto operator "" _u10(unsigned long long int x) { return dpf::modints::modint10_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u11(unsigned long long int x) { return dpf::modints::modint11_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u12(unsigned long long int x) { return dpf::modints::modint12_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u13(unsigned long long int x) { return dpf::modints::modint13_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u14(unsigned long long int x) { return dpf::modints::modint14_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u15(unsigned long long int x) { return dpf::modints::modint15_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u16(unsigned long long int x) { return dpf::modints::modint16_t{static_cast<psnip_uint16_t>(x)}; }
constexpr static auto operator "" _u17(unsigned long long int x) { return dpf::modints::modint17_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u18(unsigned long long int x) { return dpf::modints::modint18_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u19(unsigned long long int x) { return dpf::modints::modint19_t{static_cast<psnip_uint32_t>(x)}; }
// 20--29
constexpr static auto operator "" _u20(unsigned long long int x) { return dpf::modints::modint20_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u21(unsigned long long int x) { return dpf::modints::modint21_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u22(unsigned long long int x) { return dpf::modints::modint22_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u23(unsigned long long int x) { return dpf::modints::modint23_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u24(unsigned long long int x) { return dpf::modints::modint24_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u25(unsigned long long int x) { return dpf::modints::modint25_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u26(unsigned long long int x) { return dpf::modints::modint26_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u27(unsigned long long int x) { return dpf::modints::modint27_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u28(unsigned long long int x) { return dpf::modints::modint28_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u29(unsigned long long int x) { return dpf::modints::modint29_t{static_cast<psnip_uint32_t>(x)}; }
// 30--39
constexpr static auto operator "" _u30(unsigned long long int x) { return dpf::modints::modint30_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u31(unsigned long long int x) { return dpf::modints::modint31_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u32(unsigned long long int x) { return dpf::modints::modint32_t{static_cast<psnip_uint32_t>(x)}; }
constexpr static auto operator "" _u33(unsigned long long int x) { return dpf::modints::modint33_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u34(unsigned long long int x) { return dpf::modints::modint34_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u35(unsigned long long int x) { return dpf::modints::modint35_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u36(unsigned long long int x) { return dpf::modints::modint36_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u37(unsigned long long int x) { return dpf::modints::modint37_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u38(unsigned long long int x) { return dpf::modints::modint38_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u39(unsigned long long int x) { return dpf::modints::modint39_t{static_cast<psnip_uint64_t>(x)}; }
// 40--49
constexpr static auto operator "" _u40(unsigned long long int x) { return dpf::modints::modint40_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u41(unsigned long long int x) { return dpf::modints::modint41_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u42(unsigned long long int x) { return dpf::modints::modint42_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u43(unsigned long long int x) { return dpf::modints::modint43_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u44(unsigned long long int x) { return dpf::modints::modint44_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u45(unsigned long long int x) { return dpf::modints::modint45_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u46(unsigned long long int x) { return dpf::modints::modint46_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u47(unsigned long long int x) { return dpf::modints::modint47_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u48(unsigned long long int x) { return dpf::modints::modint48_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u49(unsigned long long int x) { return dpf::modints::modint49_t{static_cast<psnip_uint64_t>(x)}; }
// 50--59
constexpr static auto operator "" _u50(unsigned long long int x) { return dpf::modints::modint50_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u51(unsigned long long int x) { return dpf::modints::modint51_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u52(unsigned long long int x) { return dpf::modints::modint52_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u53(unsigned long long int x) { return dpf::modints::modint53_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u54(unsigned long long int x) { return dpf::modints::modint54_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u55(unsigned long long int x) { return dpf::modints::modint55_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u56(unsigned long long int x) { return dpf::modints::modint56_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u57(unsigned long long int x) { return dpf::modints::modint57_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u58(unsigned long long int x) { return dpf::modints::modint58_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u59(unsigned long long int x) { return dpf::modints::modint59_t{static_cast<psnip_uint64_t>(x)}; }
// 60--69
constexpr static auto operator "" _u60(unsigned long long int x) { return dpf::modints::modint60_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u61(unsigned long long int x) { return dpf::modints::modint61_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u62(unsigned long long int x) { return dpf::modints::modint62_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u63(unsigned long long int x) { return dpf::modints::modint63_t{static_cast<psnip_uint64_t>(x)}; }
constexpr static auto operator "" _u64(unsigned long long int x) { return dpf::modints::modint64_t{static_cast<psnip_uint64_t>(x)}; }
template <char ...digits> constexpr static auto operator "" _u65() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint65_t{x}; }
template <char ...digits> constexpr static auto operator "" _u66() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint66_t{x}; }
template <char ...digits> constexpr static auto operator "" _u67() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint67_t{x}; }
template <char ...digits> constexpr static auto operator "" _u68() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint68_t{x}; }
template <char ...digits> constexpr static auto operator "" _u69() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint69_t{x}; }
// 70--79
template <char ...digits> constexpr static auto operator "" _u70() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint70_t{x}; }
template <char ...digits> constexpr static auto operator "" _u71() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint71_t{x}; }
template <char ...digits> constexpr static auto operator "" _u72() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint72_t{x}; }
template <char ...digits> constexpr static auto operator "" _u73() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint73_t{x}; }
template <char ...digits> constexpr static auto operator "" _u74() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint74_t{x}; }
template <char ...digits> constexpr static auto operator "" _u75() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint75_t{x}; }
template <char ...digits> constexpr static auto operator "" _u76() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint76_t{x}; }
template <char ...digits> constexpr static auto operator "" _u77() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint77_t{x}; }
template <char ...digits> constexpr static auto operator "" _u78() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint78_t{x}; }
template <char ...digits> constexpr static auto operator "" _u79() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint79_t{x}; }
// 80--89
template <char ...digits> constexpr static auto operator "" _u80() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint80_t{x}; }
template <char ...digits> constexpr static auto operator "" _u81() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint81_t{x}; }
template <char ...digits> constexpr static auto operator "" _u82() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint82_t{x}; }
template <char ...digits> constexpr static auto operator "" _u83() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint83_t{x}; }
template <char ...digits> constexpr static auto operator "" _u84() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint84_t{x}; }
template <char ...digits> constexpr static auto operator "" _u85() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint85_t{x}; }
template <char ...digits> constexpr static auto operator "" _u86() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint86_t{x}; }
template <char ...digits> constexpr static auto operator "" _u87() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint87_t{x}; }
template <char ...digits> constexpr static auto operator "" _u88() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint88_t{x}; }
template <char ...digits> constexpr static auto operator "" _u89() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint89_t{x}; }
// 90--99
template <char ...digits> constexpr static auto operator "" _u90() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint90_t{x}; }
template <char ...digits> constexpr static auto operator "" _u91() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint91_t{x}; }
template <char ...digits> constexpr static auto operator "" _u92() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint92_t{x}; }
template <char ...digits> constexpr static auto operator "" _u93() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint93_t{x}; }
template <char ...digits> constexpr static auto operator "" _u94() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint94_t{x}; }
template <char ...digits> constexpr static auto operator "" _u95() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint95_t{x}; }
template <char ...digits> constexpr static auto operator "" _u96() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint96_t{x}; }
template <char ...digits> constexpr static auto operator "" _u97() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint97_t{x}; }
template <char ...digits> constexpr static auto operator "" _u98() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint98_t{x}; }
template <char ...digits> constexpr static auto operator "" _u99() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint99_t{x}; }
// 100--109
template <char ...digits> constexpr static auto operator "" _u100() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint100_t{x}; }
template <char ...digits> constexpr static auto operator "" _u101() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint101_t{x}; }
template <char ...digits> constexpr static auto operator "" _u102() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint102_t{x}; }
template <char ...digits> constexpr static auto operator "" _u103() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint103_t{x}; }
template <char ...digits> constexpr static auto operator "" _u104() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint104_t{x}; }
template <char ...digits> constexpr static auto operator "" _u105() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint105_t{x}; }
template <char ...digits> constexpr static auto operator "" _u106() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint106_t{x}; }
template <char ...digits> constexpr static auto operator "" _u107() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint107_t{x}; }
template <char ...digits> constexpr static auto operator "" _u108() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint108_t{x}; }
template <char ...digits> constexpr static auto operator "" _u109() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint109_t{x}; }
// 110--119
template <char ...digits> constexpr static auto operator "" _u110() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint110_t{x}; }
template <char ...digits> constexpr static auto operator "" _u111() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint111_t{x}; }
template <char ...digits> constexpr static auto operator "" _u112() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint112_t{x}; }
template <char ...digits> constexpr static auto operator "" _u113() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint113_t{x}; }
template <char ...digits> constexpr static auto operator "" _u114() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint114_t{x}; }
template <char ...digits> constexpr static auto operator "" _u115() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint115_t{x}; }
template <char ...digits> constexpr static auto operator "" _u116() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint116_t{x}; }
template <char ...digits> constexpr static auto operator "" _u117() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint117_t{x}; }
template <char ...digits> constexpr static auto operator "" _u118() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint118_t{x}; }
template <char ...digits> constexpr static auto operator "" _u119() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint119_t{x}; }
// 120--128
template <char ...digits> constexpr static auto operator "" _u120() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint120_t{x}; }
template <char ...digits> constexpr static auto operator "" _u121() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint121_t{x}; }
template <char ...digits> constexpr static auto operator "" _u122() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint122_t{x}; }
template <char ...digits> constexpr static auto operator "" _u123() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint123_t{x}; }
template <char ...digits> constexpr static auto operator "" _u124() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint124_t{x}; }
template <char ...digits> constexpr static auto operator "" _u125() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint125_t{x}; }
template <char ...digits> constexpr static auto operator "" _u126() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint126_t{x}; }
template <char ...digits> constexpr static auto operator "" _u127() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint127_t{x}; }
template <char ...digits> constexpr static auto operator "" _u128() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); simde_uint128 x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint128_t{x}; }
template <char ...digits> constexpr static auto operator "" _u129() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint129_t{x}; }

// 120--139
template <char ...digits> constexpr static auto operator "" _u130() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint130_t{x}; }
template <char ...digits> constexpr static auto operator "" _u131() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint131_t{x}; }
template <char ...digits> constexpr static auto operator "" _u132() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint132_t{x}; }
template <char ...digits> constexpr static auto operator "" _u133() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint133_t{x}; }
template <char ...digits> constexpr static auto operator "" _u134() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint134_t{x}; }
template <char ...digits> constexpr static auto operator "" _u135() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint135_t{x}; }
template <char ...digits> constexpr static auto operator "" _u136() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint136_t{x}; }
template <char ...digits> constexpr static auto operator "" _u137() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint137_t{x}; }
template <char ...digits> constexpr static auto operator "" _u138() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint138_t{x}; }
template <char ...digits> constexpr static auto operator "" _u139() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint139_t{x}; }
// 140--149
template <char ...digits> constexpr static auto operator "" _u140() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint140_t{x}; }
template <char ...digits> constexpr static auto operator "" _u141() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint141_t{x}; }
template <char ...digits> constexpr static auto operator "" _u142() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint142_t{x}; }
template <char ...digits> constexpr static auto operator "" _u143() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint143_t{x}; }
template <char ...digits> constexpr static auto operator "" _u144() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint144_t{x}; }
template <char ...digits> constexpr static auto operator "" _u145() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint145_t{x}; }
template <char ...digits> constexpr static auto operator "" _u146() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint146_t{x}; }
template <char ...digits> constexpr static auto operator "" _u147() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint147_t{x}; }
template <char ...digits> constexpr static auto operator "" _u148() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint148_t{x}; }
template <char ...digits> constexpr static auto operator "" _u149() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint149_t{x}; }
// 150--159
template <char ...digits> constexpr static auto operator "" _u150() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint150_t{x}; }
template <char ...digits> constexpr static auto operator "" _u151() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint151_t{x}; }
template <char ...digits> constexpr static auto operator "" _u152() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint152_t{x}; }
template <char ...digits> constexpr static auto operator "" _u153() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint153_t{x}; }
template <char ...digits> constexpr static auto operator "" _u154() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint154_t{x}; }
template <char ...digits> constexpr static auto operator "" _u155() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint155_t{x}; }
template <char ...digits> constexpr static auto operator "" _u156() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint156_t{x}; }
template <char ...digits> constexpr static auto operator "" _u157() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint157_t{x}; }
template <char ...digits> constexpr static auto operator "" _u158() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint158_t{x}; }
template <char ...digits> constexpr static auto operator "" _u159() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint159_t{x}; }
// 160--169
template <char ...digits> constexpr static auto operator "" _u160() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint160_t{x}; }
template <char ...digits> constexpr static auto operator "" _u161() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint161_t{x}; }
template <char ...digits> constexpr static auto operator "" _u162() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint162_t{x}; }
template <char ...digits> constexpr static auto operator "" _u163() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint163_t{x}; }
template <char ...digits> constexpr static auto operator "" _u164() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint164_t{x}; }
template <char ...digits> constexpr static auto operator "" _u165() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint165_t{x}; }
template <char ...digits> constexpr static auto operator "" _u166() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint166_t{x}; }
template <char ...digits> constexpr static auto operator "" _u167() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint167_t{x}; }
template <char ...digits> constexpr static auto operator "" _u168() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint168_t{x}; }
template <char ...digits> constexpr static auto operator "" _u169() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint169_t{x}; }
// 170-179
template <char ...digits> constexpr static auto operator "" _u170() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint170_t{x}; }
template <char ...digits> constexpr static auto operator "" _u171() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint171_t{x}; }
template <char ...digits> constexpr static auto operator "" _u172() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint172_t{x}; }
template <char ...digits> constexpr static auto operator "" _u173() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint173_t{x}; }
template <char ...digits> constexpr static auto operator "" _u174() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint174_t{x}; }
template <char ...digits> constexpr static auto operator "" _u175() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint175_t{x}; }
template <char ...digits> constexpr static auto operator "" _u176() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint176_t{x}; }
template <char ...digits> constexpr static auto operator "" _u177() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint177_t{x}; }
template <char ...digits> constexpr static auto operator "" _u178() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint178_t{x}; }
template <char ...digits> constexpr static auto operator "" _u179() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint179_t{x}; }
// 180--189
template <char ...digits> constexpr static auto operator "" _u180() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint180_t{x}; }
template <char ...digits> constexpr static auto operator "" _u181() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint181_t{x}; }
template <char ...digits> constexpr static auto operator "" _u182() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint182_t{x}; }
template <char ...digits> constexpr static auto operator "" _u183() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint183_t{x}; }
template <char ...digits> constexpr static auto operator "" _u184() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint184_t{x}; }
template <char ...digits> constexpr static auto operator "" _u185() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint185_t{x}; }
template <char ...digits> constexpr static auto operator "" _u186() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint186_t{x}; }
template <char ...digits> constexpr static auto operator "" _u187() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint187_t{x}; }
template <char ...digits> constexpr static auto operator "" _u188() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint188_t{x}; }
template <char ...digits> constexpr static auto operator "" _u189() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint189_t{x}; }
// 190--199
template <char ...digits> constexpr static auto operator "" _u190() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint190_t{x}; }
template <char ...digits> constexpr static auto operator "" _u191() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint191_t{x}; }
template <char ...digits> constexpr static auto operator "" _u192() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint192_t{x}; }
template <char ...digits> constexpr static auto operator "" _u193() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint193_t{x}; }
template <char ...digits> constexpr static auto operator "" _u194() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint194_t{x}; }
template <char ...digits> constexpr static auto operator "" _u195() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint195_t{x}; }
template <char ...digits> constexpr static auto operator "" _u196() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint196_t{x}; }
template <char ...digits> constexpr static auto operator "" _u197() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint197_t{x}; }
template <char ...digits> constexpr static auto operator "" _u198() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint198_t{x}; }
template <char ...digits> constexpr static auto operator "" _u199() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint199_t{x}; }
// 200--209
template <char ...digits> constexpr static auto operator "" _u200() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint200_t{x}; }
template <char ...digits> constexpr static auto operator "" _u201() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint201_t{x}; }
template <char ...digits> constexpr static auto operator "" _u202() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint202_t{x}; }
template <char ...digits> constexpr static auto operator "" _u203() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint203_t{x}; }
template <char ...digits> constexpr static auto operator "" _u204() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint204_t{x}; }
template <char ...digits> constexpr static auto operator "" _u205() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint205_t{x}; }
template <char ...digits> constexpr static auto operator "" _u206() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint206_t{x}; }
template <char ...digits> constexpr static auto operator "" _u207() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint207_t{x}; }
template <char ...digits> constexpr static auto operator "" _u208() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint208_t{x}; }
template <char ...digits> constexpr static auto operator "" _u209() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint209_t{x}; }
// 210--219
template <char ...digits> constexpr static auto operator "" _u210() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint210_t{x}; }
template <char ...digits> constexpr static auto operator "" _u211() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint211_t{x}; }
template <char ...digits> constexpr static auto operator "" _u212() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint212_t{x}; }
template <char ...digits> constexpr static auto operator "" _u213() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint213_t{x}; }
template <char ...digits> constexpr static auto operator "" _u214() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint214_t{x}; }
template <char ...digits> constexpr static auto operator "" _u215() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint215_t{x}; }
template <char ...digits> constexpr static auto operator "" _u216() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint216_t{x}; }
template <char ...digits> constexpr static auto operator "" _u217() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint217_t{x}; }
template <char ...digits> constexpr static auto operator "" _u218() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint218_t{x}; }
template <char ...digits> constexpr static auto operator "" _u219() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint219_t{x}; }
// 220--229
template <char ...digits> constexpr static auto operator "" _u220() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint220_t{x}; }
template <char ...digits> constexpr static auto operator "" _u221() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint221_t{x}; }
template <char ...digits> constexpr static auto operator "" _u222() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint222_t{x}; }
template <char ...digits> constexpr static auto operator "" _u223() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint223_t{x}; }
template <char ...digits> constexpr static auto operator "" _u224() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint224_t{x}; }
template <char ...digits> constexpr static auto operator "" _u225() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint225_t{x}; }
template <char ...digits> constexpr static auto operator "" _u226() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint226_t{x}; }
template <char ...digits> constexpr static auto operator "" _u227() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint227_t{x}; }
template <char ...digits> constexpr static auto operator "" _u228() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint228_t{x}; }
template <char ...digits> constexpr static auto operator "" _u229() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint229_t{x}; }
// 230--239
template <char ...digits> constexpr static auto operator "" _u230() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint230_t{x}; }
template <char ...digits> constexpr static auto operator "" _u231() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint231_t{x}; }
template <char ...digits> constexpr static auto operator "" _u232() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint232_t{x}; }
template <char ...digits> constexpr static auto operator "" _u233() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint233_t{x}; }
template <char ...digits> constexpr static auto operator "" _u234() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint234_t{x}; }
template <char ...digits> constexpr static auto operator "" _u235() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint235_t{x}; }
template <char ...digits> constexpr static auto operator "" _u236() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint236_t{x}; }
template <char ...digits> constexpr static auto operator "" _u237() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint237_t{x}; }
template <char ...digits> constexpr static auto operator "" _u238() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint238_t{x}; }
template <char ...digits> constexpr static auto operator "" _u239() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint239_t{x}; }
// 240--249
template <char ...digits> constexpr static auto operator "" _u240() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint240_t{x}; }
template <char ...digits> constexpr static auto operator "" _u241() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint241_t{x}; }
template <char ...digits> constexpr static auto operator "" _u242() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint242_t{x}; }
template <char ...digits> constexpr static auto operator "" _u243() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint243_t{x}; }
template <char ...digits> constexpr static auto operator "" _u244() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint244_t{x}; }
template <char ...digits> constexpr static auto operator "" _u245() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint245_t{x}; }
template <char ...digits> constexpr static auto operator "" _u246() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint246_t{x}; }
template <char ...digits> constexpr static auto operator "" _u247() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint247_t{x}; }
template <char ...digits> constexpr static auto operator "" _u248() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint248_t{x}; }
template <char ...digits> constexpr static auto operator "" _u249() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint249_t{x}; }
// 250--256
template <char ...digits> constexpr static auto operator "" _u250() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint250_t{x}; }
template <char ...digits> constexpr static auto operator "" _u251() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint251_t{x}; }
template <char ...digits> constexpr static auto operator "" _u252() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint252_t{x}; }
template <char ...digits> constexpr static auto operator "" _u253() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint253_t{x}; }
template <char ...digits> constexpr static auto operator "" _u254() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint254_t{x}; }
template <char ...digits> constexpr static auto operator "" _u255() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint255_t{x}; }
template <char ...digits> constexpr static auto operator "" _u256() { utils::constexpr_maybe_throw<std::runtime_error>(!(std::isdigit(digits) && ...), "invalid char"); uint256_t x{0}; ((x = x * 10 + (digits - '0')), ...); return dpf::modints::modint256_t{x}; }

}  // namespace modints

}  // namespace literals

}  // namespace dpf

namespace std
{

/// @brief specializes `std::numeric_limits` for CV-qualified `dpf::modint`s
/// @{

/// @details specializes `std::numeric_limits` for `dpf::modint<Nbits>`
/// @tparam Nbits width in bits
template<std::size_t Nbits>
class numeric_limits<dpf::modint<Nbits>>
{
  public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool has_infinity = false;
    static constexpr bool has_quiet_NaN = false;
    static constexpr bool has_signaling_NaN = false;
    static constexpr std::float_denorm_style has_denorm = std::denorm_absent;
    static constexpr bool has_denorm_loss = false;
    static constexpr std::float_round_style round_style = std::round_toward_zero;
    static constexpr bool is_iec559 = false;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = Nbits;
    // floor(Nbits * log10(2)); avoids a non-portable constexpr std::log10
    static constexpr int digits10 = static_cast<int>((static_cast<unsigned long long>(Nbits) * 30103ull) / 100000ull);
    static constexpr int max_digits10 = 0;
    static constexpr int radix = 2;
    static constexpr int min_exponent = 0;
    static constexpr int max_exponent = 0;
    static constexpr int min_exponent10 = 0;
    static constexpr int max_exponent10 = 0;
    static constexpr bool traps
        = std::numeric_limits<typename dpf::modint<Nbits>::integral_type>::traps;
    static constexpr bool tinyness_before = false;

    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> min() noexcept { return dpf::modint<Nbits>{0}; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> lowest() noexcept { return dpf::modint<Nbits>{0}; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> max() noexcept { return ~dpf::modint<Nbits>{0}; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> epsilon() noexcept { return 0; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> round_error() noexcept { return 0; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> infinity() noexcept { return 0; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> quiet_NaN() noexcept { return 0; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> signaling_NaN() noexcept { return 0; }
    HEDLEY_NO_THROW
    static constexpr dpf::modint<Nbits> denorm_min() noexcept { return 0; }
};

/// @details specializes `std::numeric_limits` for `dpf::modint<Nbits> const`
/// @tparam Nbits width in bits
template<std::size_t Nbits>
class numeric_limits<dpf::modint<Nbits> const>
  : public numeric_limits<dpf::modint<Nbits>> {};

/// @details specializes `std::numeric_limits` for
/// @brief `dpf::modint<Nbits> volatile`
/// @tparam Nbits width in bits
template<std::size_t Nbits>
class numeric_limits<dpf::modint<Nbits> volatile>
  : public numeric_limits<dpf::modint<Nbits>> {};

/// @details specializes `std::numeric_limits` for
/// @brief `dpf::modint<Nbits> const volatile`
/// @tparam Nbits width in bits
template<std::size_t Nbits>
class numeric_limits<dpf::modint<Nbits> const volatile>
  : public numeric_limits<dpf::modint<Nbits>> {};

/// @}

}  // namespace std

#endif  // LIBDPF_INCLUDE_DPF_MODINT_HPP__