Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at apescan.io on 2025-03-17
*/

/**

 * ██████╗ ██████╗  ██████╗      ██╗███████╗ ██████╗████████╗     █████╗     
 * ██╔══██╗██╔══██╗██╔═══██╗     ██║██╔════╝██╔════╝╚══██╔══╝    ██╔══██╗    
 * ██████╔╝██████╔╝██║   ██║     ██║█████╗  ██║        ██║       ╚██████║    
 * ██╔═══╝ ██╔══██╗██║   ██║██   ██║██╔══╝  ██║        ██║        ╚═══██║    
 * ██║     ██║  ██║╚██████╔╝╚█████╔╝███████╗╚██████╗   ██║        █████╔╝    
 * ╚═╝     ╚═╝  ╚═╝ ╚═════╝  ╚════╝ ╚══════╝ ╚═════╝   ╚═╝        ╚════╝     
                                                                        
 *  On-chain Project-9 OnChain Data, by SoftWave.
 **/

// File: @openzeppelin/contracts/utils/Panic.sol


// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)

pragma solidity ^0.8.20;

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 *
 * _Available since v5.1._
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SafeCast.sol


// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;



/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a < b, a, b);
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2²⁵⁶ + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 exp;
        unchecked {
            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
            value >>= exp;
            result += exp;

            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
            value >>= exp;
            result += exp;

            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
            value >>= exp;
            result += exp;

            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
            value >>= exp;
            result += exp;

            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
            value >>= exp;
            result += exp;

            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
            value >>= exp;
            result += exp;

            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
            value >>= exp;
            result += exp;

            result += SafeCast.toUint(value > 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;


/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
        }
    }

    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return ternary(a < b, a, b);
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
            // taking advantage of the most significant (or "sign" bit) in two's complement representation.
            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
            int256 mask = n >> 255;

            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
            return uint256((n + mask) ^ mask);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.2.0) (utils/Strings.sol)

pragma solidity ^0.8.20;




/**
 * @dev String operations.
 */
library Strings {
    using SafeCast for *;

    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev The string being parsed contains characters that are not in scope of the given base.
     */
    error StringsInvalidChar();

    /**
     * @dev The string being parsed is not a properly formatted address.
     */
    error StringsInvalidAddressFormat();

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            assembly ("memory-safe") {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                assembly ("memory-safe") {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
     * representation, according to EIP-55.
     */
    function toChecksumHexString(address addr) internal pure returns (string memory) {
        bytes memory buffer = bytes(toHexString(addr));

        // hash the hex part of buffer (skip length + 2 bytes, length 40)
        uint256 hashValue;
        assembly ("memory-safe") {
            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
        }

        for (uint256 i = 41; i > 1; --i) {
            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
                // case shift by xoring with 0x20
                buffer[i] ^= 0x20;
            }
            hashValue >>= 4;
        }
        return string(buffer);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }

    /**
     * @dev Parse a decimal string and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input) internal pure returns (uint256) {
        return parseUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[0-9]*`
     * - The result must fit into an `uint256` type
     */
    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseUint} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        uint256 result = 0;
        for (uint256 i = begin; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 9) return (false, 0);
            result *= 10;
            result += chr;
        }
        return (true, result);
    }

    /**
     * @dev Parse a decimal string and returns the value as a `int256`.
     *
     * Requirements:
     * - The string must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input) internal pure returns (int256) {
        return parseInt(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `[-+]?[0-9]*`
     * - The result must fit in an `int256` type.
     */
    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {
        (bool success, int256 value) = tryParseInt(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if
     * the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {
        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);
    }

    uint256 private constant ABS_MIN_INT256 = 2 ** 255;

    /**
     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid
     * character or if the result does not fit in a `int256`.
     *
     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.
     */
    function tryParseInt(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, int256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseIntUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseInt} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseIntUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, int256 value) {
        bytes memory buffer = bytes(input);

        // Check presence of a negative sign.
        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        bool positiveSign = sign == bytes1("+");
        bool negativeSign = sign == bytes1("-");
        uint256 offset = (positiveSign || negativeSign).toUint();

        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);

        if (absSuccess && absValue < ABS_MIN_INT256) {
            return (true, negativeSign ? -int256(absValue) : int256(absValue));
        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {
            return (true, type(int256).min);
        } else return (false, 0);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a `uint256`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input) internal pure returns (uint256) {
        return parseHexUint(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`
     * - The result must fit in an `uint256` type.
     */
    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {
        (bool success, uint256 value) = tryParseHexUint(input, begin, end);
        if (!success) revert StringsInvalidChar();
        return value;
    }

    /**
     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {
        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an
     * invalid character.
     *
     * NOTE: This function will revert if the result does not fit in a `uint256`.
     */
    function tryParseHexUint(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, uint256 value) {
        if (end > bytes(input).length || begin > end) return (false, 0);
        return _tryParseHexUintUncheckedBounds(input, begin, end);
    }

    /**
     * @dev Implementation of {tryParseHexUint} that does not check bounds. Caller should make sure that
     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.
     */
    function _tryParseHexUintUncheckedBounds(
        string memory input,
        uint256 begin,
        uint256 end
    ) private pure returns (bool success, uint256 value) {
        bytes memory buffer = bytes(input);

        // skip 0x prefix if present
        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 offset = hasPrefix.toUint() * 2;

        uint256 result = 0;
        for (uint256 i = begin + offset; i < end; ++i) {
            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));
            if (chr > 15) return (false, 0);
            result *= 16;
            unchecked {
                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).
                // This guaratees that adding a value < 16 will not cause an overflow, hence the unchecked.
                result += chr;
            }
        }
        return (true, result);
    }

    /**
     * @dev Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an `address`.
     *
     * Requirements:
     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input) internal pure returns (address) {
        return parseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress} that parses a substring of `input` located between position `begin` (included) and
     * `end` (excluded).
     *
     * Requirements:
     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`
     */
    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {
        (bool success, address value) = tryParseAddress(input, begin, end);
        if (!success) revert StringsInvalidAddressFormat();
        return value;
    }

    /**
     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly
     * formatted address. See {parseAddress} requirements.
     */
    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {
        return tryParseAddress(input, 0, bytes(input).length);
    }

    /**
     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly
     * formatted address. See {parseAddress} requirements.
     */
    function tryParseAddress(
        string memory input,
        uint256 begin,
        uint256 end
    ) internal pure returns (bool success, address value) {
        if (end > bytes(input).length || begin > end) return (false, address(0));

        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2("0x"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty
        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;

        // check that input is the correct length
        if (end - begin == expectedLength) {
            // length guarantees that this does not overflow, and value is at most type(uint160).max
            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);
            return (s, address(uint160(v)));
        } else {
            return (false, address(0));
        }
    }

    function _tryParseChr(bytes1 chr) private pure returns (uint8) {
        uint8 value = uint8(chr);

        // Try to parse `chr`:
        // - Case 1: [0-9]
        // - Case 2: [a-f]
        // - Case 3: [A-F]
        // - otherwise not supported
        unchecked {
            if (value > 47 && value < 58) value -= 48;
            else if (value > 96 && value < 103) value -= 87;
            else if (value > 64 && value < 71) value -= 55;
            else return type(uint8).max;
        }

        return value;
    }

    /**
     * @dev Reads a bytes32 from a bytes array without bounds checking.
     *
     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the
     * assembly block as such would prevent some optimizations.
     */
    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {
        // This is not memory safe in the general case, but all calls to this private function are within bounds.
        assembly ("memory-safe") {
            value := mload(add(buffer, add(0x20, offset)))
        }
    }
}

// File: contracts/ProjectNineData.sol

pragma solidity ^0.8.0;


contract ProjectNineData {
    address payable internal deployer;
    address payable public nftContract;

    bool private contractLocked = false;
    uint256 private constant CANVAS_SIZE = 24;
    uint256 private constant PIXEL_DATA_SIZE = CANVAS_SIZE * CANVAS_SIZE * 3;
    uint256 public constant MAX_LIMIT = 2222;
    Coordination public updateCoord;

    struct Trait {
        string traitType;
        string value;
    }

    struct Coordination {
        uint256 startX;
        uint256 startY;
        uint256 width;
        uint256 height;
    }

    struct NineData {
        bytes pixelData;
        Trait[] traits;
        bytes equippedWeapon;
        uint256 xp;
    }

    mapping(uint256 => NineData) private nineData;

    modifier onlyNFTContract() {
        require(msg.sender == nftContract, "Only NFTContract.");
        _;
    }

    modifier onlyDeployer() {
        require(msg.sender == deployer, "Only deployer.");
        _;
    }

    modifier unlocked() {
        require(!contractLocked, "Contract is locked.");
        _;
    }

    constructor() {
        deployer = payable(msg.sender);
    }

    function setNFTContract(address contractAddress) external onlyDeployer {
        nftContract = payable(contractAddress);
    }

    function setUpdateCoordination(
        uint256 startX,
        uint256 startY,
        uint256 width,
        uint256 height
    ) external onlyDeployer {
        require(startX + width <= CANVAS_SIZE, "Width out of bounds");
        require(startY + height <= CANVAS_SIZE, "Height out of bounds");
        updateCoord = Coordination(startX, startY, width, height);
    }

    function lockContract() external onlyDeployer unlocked {
        contractLocked = true;
    }

    function storePixelData(uint256 tokenId, bytes memory pixelData)
        external
        onlyDeployer
        unlocked
    {
        require(tokenId < MAX_LIMIT, "Invalid tokenId");
        require(
            pixelData.length == PIXEL_DATA_SIZE,
            "Invalid pixel data length"
        );
        nineData[tokenId].pixelData = pixelData;
    }

    function batchStorePixelData(
        uint256[] memory tokenIds,
        bytes[] memory pixelDataArray
    ) external onlyDeployer unlocked {
        require(tokenIds.length == pixelDataArray.length, "Mismatched arrays");
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            bytes memory pixelData = pixelDataArray[i];
            require(tokenId < MAX_LIMIT, "Invalid tokenId");
            require(
                pixelData.length == PIXEL_DATA_SIZE,
                "Invalid pixel data length"
            );
            nineData[tokenId].pixelData = pixelData;
        }
    }

    function storeTraits(uint256 tokenId, Trait[] memory traits)
        external
        onlyDeployer
        unlocked
    {
        require(traits.length > 0, "Traits cannot be empty");
        delete nineData[tokenId].traits;
        for (uint256 i = 0; i < traits.length; i++) {
            nineData[tokenId].traits.push(traits[i]);
        }
    }

    function batchStoreTraits(
        uint256[] memory tokenIds,
        Trait[][] memory traitsArray
    ) external onlyDeployer unlocked {
        require(tokenIds.length == traitsArray.length, "Mismatched arrays");
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            Trait[] memory traits = traitsArray[i];
            delete nineData[tokenId].traits;
            for (uint256 j = 0; j < traits.length; j++) {
                nineData[tokenId].traits.push(traits[j]);
            }
        }
    }

    function getTraits(uint256 tokenId) external view returns (string memory) {
        require(nineData[tokenId].traits.length > 0, "Traits not set");

        bytes memory jsonTraits = "[";

        for (uint256 i = 0; i < nineData[tokenId].traits.length; i++) {
            jsonTraits = abi.encodePacked(
                jsonTraits,
                '{"trait_type":"',
                nineData[tokenId].traits[i].traitType,
                '","value":"',
                nineData[tokenId].traits[i].value,
                '"}'
            );

            if (i < nineData[tokenId].traits.length - 1) {
                jsonTraits = abi.encodePacked(jsonTraits, ",");
            }
        }

        // Append XP
        if (nineData[tokenId].traits.length > 0) {
            jsonTraits = abi.encodePacked(jsonTraits, ",");
        }

        jsonTraits = abi.encodePacked(
            jsonTraits,
            '{"trait_type":"XP","value":"',
            Strings.toString(nineData[tokenId].xp),
            '"}'
        );

        // Append hasWeapon
        bool hasWeapon = nineData[tokenId].equippedWeapon.length > 0;
        jsonTraits = abi.encodePacked(
            jsonTraits,
            ',{"trait_type":"hasWeapon","value":"',
            hasWeapon ? "yes" : "no",
            '"}]'
        );

        return string(jsonTraits);
    }

    function getNineData(uint256 tokenId) external view returns (bytes memory) {
        require(tokenId < MAX_LIMIT, "Invalid tokenId");
        require(
            nineData[tokenId].pixelData.length == PIXEL_DATA_SIZE,
            "Pixel data not set"
        );
        return nineData[tokenId].pixelData;
    }

    function updateWeapon(uint256 tokenId, bytes memory newWeapon)
        external
        onlyNFTContract
    {
        uint256 area = updateCoord.width * updateCoord.height;
        require(
            newWeapon.length == area * 3,
            "newWeapon array length mismatch"
        );

        nineData[tokenId].equippedWeapon = newWeapon;

        if (nineData[tokenId].xp < 3) nineData[tokenId].xp += 1;
    }

    function updateTrait(
        uint256 tokenId,
        string memory traitType,
        string memory value
    ) external onlyNFTContract {
        Trait[] storage traits = nineData[tokenId].traits;
        for (uint256 i = 0; i < traits.length; i++) {
            if (
                keccak256(bytes(traits[i].traitType)) ==
                keccak256(bytes(traitType))
            ) {
                traits[i].value = value;
                return;
            }
        }
        traits.push(Trait(traitType, value));
    }

    function getEquippedWeapon(uint256 tokenId)
        external
        view
        returns (bytes memory)
    {
        return nineData[tokenId].equippedWeapon;
    }

    function train(uint256 tokenId) external onlyNFTContract {
        if (nineData[tokenId].xp < 3) nineData[tokenId].xp += 1;
    }

    function exercise(uint256 tokenId) external onlyNFTContract {
        if (nineData[tokenId].xp < 3) nineData[tokenId].xp += 1;
    }

    function getXP(uint256 tokenId) external view returns (uint256) {
        return nineData[tokenId].xp;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"MAX_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bytes[]","name":"pixelDataArray","type":"bytes[]"}],"name":"batchStorePixelData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"components":[{"internalType":"string","name":"traitType","type":"string"},{"internalType":"string","name":"value","type":"string"}],"internalType":"struct ProjectNineData.Trait[][]","name":"traitsArray","type":"tuple[][]"}],"name":"batchStoreTraits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exercise","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getEquippedWeapon","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getNineData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getTraits","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getXP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nftContract","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"}],"name":"setNFTContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startX","type":"uint256"},{"internalType":"uint256","name":"startY","type":"uint256"},{"internalType":"uint256","name":"width","type":"uint256"},{"internalType":"uint256","name":"height","type":"uint256"}],"name":"setUpdateCoordination","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"pixelData","type":"bytes"}],"name":"storePixelData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"components":[{"internalType":"string","name":"traitType","type":"string"},{"internalType":"string","name":"value","type":"string"}],"internalType":"struct ProjectNineData.Trait[]","name":"traits","type":"tuple[]"}],"name":"storeTraits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"train","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"updateCoord","outputs":[{"internalType":"uint256","name":"startX","type":"uint256"},{"internalType":"uint256","name":"startY","type":"uint256"},{"internalType":"uint256","name":"width","type":"uint256"},{"internalType":"uint256","name":"height","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"traitType","type":"string"},{"internalType":"string","name":"value","type":"string"}],"name":"updateTrait","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"newWeapon","type":"bytes"}],"name":"updateWeapon","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

88267:7068:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90452:654;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;88551:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;94941:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;94762:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89976:95;;;:::i;:::-;;91114:358;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89451:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;95080:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89587:381;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;88598:31;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;95222:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;88339:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;93774:428;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;91480:569;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;90079:365;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;92057:1383;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;94210:544;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;93448:318;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90452:654;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89314:14:::1;;;;;;;;;;;89313:15;89305:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;90633:14:::2;:21;90614:8;:15;:40;90606:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;90692:9;90687:412;90711:8;:15;90707:1;:19;90687:412;;;90748:15;90766:8;90775:1;90766:11;;;;;;;;:::i;:::-;;;;;;;;90748:29;;90792:22;90817:14;90832:1;90817:17;;;;;;;;:::i;:::-;;;;;;;;90792:42;;88587:4;90857:7;:19;90849:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;88543:1;88463:2;::::0;88515:25:::2;;;;:::i;:::-;:29;;;;:::i;:::-;90937:9;:16;:35;90911:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;91078:9;91048:8;:17;91057:7;91048:17;;;;;;;;;;;:27;;:39;;;;;;:::i;:::-;;90733:366;;90728:3;;;;;;;90687:412;;;;90452:654:::0;;:::o;88551:40::-;88587:4;88551:40;:::o;94941:131::-;89101:11;;;;;;;;;;;89087:25;;:10;:25;;;89079:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;95036:1:::1;95013:8;:17;95022:7;95013:17;;;;;;;;;;;:20;;;:24;95009:55;;;95063:1;95039:8;:17;95048:7;95039:17;;;;;;;;;;;:20;;;:25;;;;;;;:::i;:::-;;;;;;;;95009:55;94941:131:::0;:::o;94762:171::-;94856:12;94893:8;:17;94902:7;94893:17;;;;;;;;;;;:32;;94886:39;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94762:171;;;:::o;89976:95::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89314:14:::1;;;;;;;;;;;89313:15;89305:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;90059:4:::2;90042:14:::0;::::2;:21;;;;;;;;;;;;;;;;;;89976:95::o:0;91114:358::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89314:14:::1;;;;;;;;;;;89313:15;89305:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;91273:1:::2;91257:6;:13;:17;91249:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;91319:8;:17;91328:7;91319:17;;;;;;;;;;;:24;;;91312:31;;;;:::i;:::-;91359:9;91354:111;91378:6;:13;91374:1;:17;91354:111;;;91413:8;:17;91422:7;91413:17;;;;;;;;;;;:24;;91443:6;91450:1;91443:9;;;;;;;;:::i;:::-;;;;;;;;91413:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;91393:3;;;;;;;91354:111;;;;91114:358:::0;;:::o;89451:128::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89555:15:::1;89533:11;;:38;;;;;;;;;;;;;;;;;;89451:128:::0;:::o;95080:134::-;89101:11;;;;;;;;;;;89087:25;;:10;:25;;;89079:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;95178:1:::1;95155:8;:17;95164:7;95155:17;;;;;;;;;;;:20;;;:24;95151:55;;;95205:1;95181:8;:17;95190:7;95181:17;;;;;;;;;;;:20;;;:25;;;;;;;:::i;:::-;;;;;;;;95151:55;95080:134:::0;:::o;89587:381::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;88463:2:::1;89774:5;89765:6;:14;;;;:::i;:::-;:29;;89757:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;88463:2;89846:6;89837;:15;;;;:::i;:::-;:30;;89829:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;89917:43;;;;;;;;89930:6;89917:43;;;;89938:6;89917:43;;;;89946:5;89917:43;;;;89953:6;89917:43;;::::0;89903:11:::1;:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89587:381:::0;;;;:::o;88598:31::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;95222:110::-;95277:7;95304:8;:17;95313:7;95304:17;;;;;;;;;;;:20;;;95297:27;;95222:110;;;:::o;88339:34::-;;;;;;;;;;;;;:::o;93774:428::-;89101:11;;;;;;;;;;;89087:25;;:10;:25;;;89079:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;93896:12:::1;93931:11;:18;;;93911:11;:17:::0;::::1;;:38;;;;:::i;:::-;93896:53;;94009:1;94002:4;:8;;;;:::i;:::-;93982:9;:16;:28;93960:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;94117:9;94082:8;:17;94091:7;94082:17;;;;;;;;;;;:32;;:44;;;;;;:::i;:::-;;94166:1;94143:8;:17;94152:7;94143:17;;;;;;;;;;;:20;;;:24;94139:55;;;94193:1;94169:8;:17;94178:7;94169:17;;;;;;;;;;;:20;;;:25;;;;;;;:::i;:::-;;;;;;;;94139:55;93885:317;93774:428:::0;;:::o;91480:569::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89314:14:::1;;;;;;;;;;;89313:15;89305:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;91657:11:::2;:18;91638:8;:15;:37;91630:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;91713:9;91708:334;91732:8;:15;91728:1;:19;91708:334;;;91769:15;91787:8;91796:1;91787:11;;;;;;;;:::i;:::-;;;;;;;;91769:29;;91813:21;91837:11;91849:1;91837:14;;;;;;;;:::i;:::-;;;;;;;;91813:38;;91873:8;:17;91882:7;91873:17;;;;;;;;;;;:24;;;91866:31;;;;:::i;:::-;91917:9;91912:119;91936:6;:13;91932:1;:17;91912:119;;;91975:8;:17;91984:7;91975:17;;;;;;;;;;;:24;;92005:6;92012:1;92005:9;;;;;;;;:::i;:::-;;;;;;;;91975:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;91951:3;;;;;;;91912:119;;;;91754:288;;91749:3;;;;;;;91708:334;;;;91480:569:::0;;:::o;90079:365::-;89219:8;;;;;;;;;;89205:22;;:10;:22;;;89197:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;89314:14:::1;;;;;;;;;;;89313:15;89305:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;88587:4:::2;90226:7;:19;90218:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;88543:1;88463:2;::::0;88515:25:::2;;;;:::i;:::-;:29;;;;:::i;:::-;90298:9;:16;:35;90276:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;90427:9;90397:8;:17;90406:7;90397:17;;;;;;;;;;;:27;;:39;;;;;;:::i;:::-;;90079:365:::0;;:::o;92057:1383::-;92116:13;92184:1;92150:8;:17;92159:7;92150:17;;;;;;;;;;;:24;;:31;;;;:35;92142:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;92217:23;:29;;;;;;;;;;;;;;;;;;;92264:9;92259:503;92283:8;:17;92292:7;92283:17;;;;;;;;;;;:24;;:31;;;;92279:1;:35;92259:503;;;92384:10;92449:8;:17;92458:7;92449:17;;;;;;;;;;;:24;;92474:1;92449:27;;;;;;;;:::i;:::-;;;;;;;;;;;;:37;;92537:8;:17;92546:7;92537:17;;;;;;;;;;;:24;;92562:1;92537:27;;;;;;;;:::i;:::-;;;;;;;;;;;;:33;;92349:259;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;92336:272;;92667:1;92633:8;:17;92642:7;92633:17;;;;;;;;;;;:24;;:31;;;;:35;;;;:::i;:::-;92629:1;:39;92625:126;;;92719:10;92702:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;92689:46;;92625:126;92316:3;;;;;;;92259:503;;;;92834:1;92800:8;:17;92809:7;92800:17;;;;;;;;;;;:24;;:31;;;;:35;92796:114;;;92882:10;92865:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;92852:46;;92796:114;92966:10;93036:38;93053:8;:17;93062:7;93053:17;;;;;;;;;;;:20;;;93036:16;:38::i;:::-;92935:169;;;;;;;;;:::i;:::-;;;;;;;;;;;;;92922:182;;93146:14;93205:1;93163:8;:17;93172:7;93163:17;;;;;;;;;;;:32;;:39;;;;;:::i;:::-;;;:43;93146:60;;93261:10;93339:9;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93230:164;;;;;;;;;:::i;:::-;;;;;;;;;;;;;93217:177;;93421:10;93407:25;;;;92057:1383;;;:::o;94210:544::-;89101:11;;;;;;;;;;;89087:25;;:10;:25;;;89079:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;94364:22:::1;94389:8;:17;94398:7;94389:17;;;;;;;;;;;:24;;94364:49;;94429:9;94424:276;94448:6;:13;;;;94444:1;:17;94424:276;;;94579:9;94563:27;;;;;;94521:6;94528:1;94521:9;;;;;;;;:::i;:::-;;;;;;;;;;;;:19;;94505:37;;;;;;:::i;:::-;;;;;;;;:85:::0;94483:206:::1;;94643:5;94625:6;94632:1;94625:9;;;;;;;;:::i;:::-;;;;;;;;;;;;:15;;:23;;;;;;:::i;:::-;;94667:7;;;;94483:206;94463:3;;;;;;;94424:276;;;;94710:6;94722:23;;;;;;;;94728:9;94722:23;;;;94739:5;94722:23;;::::0;94710:36:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;94353:401;89145:1;94210:544:::0;;;:::o;93448:318::-;93509:12;88587:4;93542:7;:19;93534:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;88543:1;88463:2;;88515:25;;;;:::i;:::-;:29;;;;:::i;:::-;93614:8;:17;93623:7;93614:17;;;;;;;;;;;:27;;:34;;;;;:::i;:::-;;;:53;93592:121;;;;;;;;;;;;:::i;:::-;;;;;;;;;93731:8;:17;93740:7;93731:17;;;;;;;;;;;:27;;93724:34;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93448:318;;;:::o;71937:650::-;71993:13;72044:14;72081:1;72061:17;72072:5;72061:10;:17::i;:::-;:21;72044:38;;72097:20;72131:6;72120:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72097:41;;72153:11;72250:6;72246:2;72242:15;72234:6;72230:28;72223:35;;72287:254;72294:4;72287:254;;;72319:5;;;;;;;;72425:10;72420:2;72413:5;72409:14;72404:32;72399:3;72391:46;72483:2;72474:11;;;;;;:::i;:::-;;;;;72517:1;72508:5;:10;72287:254;72504:21;72287:254;72562:6;72555:13;;;;;71937:650;;;:::o;65264:948::-;65317:7;65337:14;65354:1;65337:18;;65404:8;65395:5;:17;65391:106;;65442:8;65433:17;;;;;;:::i;:::-;;;;;65479:2;65469:12;;;;65391:106;65524:8;65515:5;:17;65511:106;;65562:8;65553:17;;;;;;:::i;:::-;;;;;65599:2;65589:12;;;;65511:106;65644:8;65635:5;:17;65631:106;;65682:8;65673:17;;;;;;:::i;:::-;;;;;65719:2;65709:12;;;;65631:106;65764:7;65755:5;:16;65751:103;;65801:7;65792:16;;;;;;:::i;:::-;;;;;65837:1;65827:11;;;;65751:103;65881:7;65872:5;:16;65868:103;;65918:7;65909:16;;;;;;:::i;:::-;;;;;65954:1;65944:11;;;;65868:103;65998:7;65989:5;:16;65985:103;;66035:7;66026:16;;;;;;:::i;:::-;;;;;66071:1;66061:11;;;;65985:103;66115:7;66106:5;:16;66102:68;;66153:1;66143:11;;;;66102:68;66198:6;66191:13;;;65264:948;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:102;498:6;549:2;545:7;540:2;533:5;529:14;525:28;515:38;;457:102;;;:::o;565:180::-;613:77;610:1;603:88;710:4;707:1;700:15;734:4;731:1;724:15;751:281;834:27;856:4;834:27;:::i;:::-;826:6;822:40;964:6;952:10;949:22;928:18;916:10;913:34;910:62;907:88;;;975:18;;:::i;:::-;907:88;1015:10;1011:2;1004:22;794:238;751:281;;:::o;1038:129::-;1072:6;1099:20;;:::i;:::-;1089:30;;1128:33;1156:4;1148:6;1128:33;:::i;:::-;1038:129;;;:::o;1173:311::-;1250:4;1340:18;1332:6;1329:30;1326:56;;;1362:18;;:::i;:::-;1326:56;1412:4;1404:6;1400:17;1392:25;;1472:4;1466;1462:15;1454:23;;1173:311;;;:::o;1490:117::-;1599:1;1596;1589:12;1613:77;1650:7;1679:5;1668:16;;1613:77;;;:::o;1696:122::-;1769:24;1787:5;1769:24;:::i;:::-;1762:5;1759:35;1749:63;;1808:1;1805;1798:12;1749:63;1696:122;:::o;1824:139::-;1870:5;1908:6;1895:20;1886:29;;1924:33;1951:5;1924:33;:::i;:::-;1824:139;;;;:::o;1986:710::-;2082:5;2107:81;2123:64;2180:6;2123:64;:::i;:::-;2107:81;:::i;:::-;2098:90;;2208:5;2237:6;2230:5;2223:21;2271:4;2264:5;2260:16;2253:23;;2324:4;2316:6;2312:17;2304:6;2300:30;2353:3;2345:6;2342:15;2339:122;;;2372:79;;:::i;:::-;2339:122;2487:6;2470:220;2504:6;2499:3;2496:15;2470:220;;;2579:3;2608:37;2641:3;2629:10;2608:37;:::i;:::-;2603:3;2596:50;2675:4;2670:3;2666:14;2659:21;;2546:144;2530:4;2525:3;2521:14;2514:21;;2470:220;;;2474:21;2088:608;;1986:710;;;;;:::o;2719:370::-;2790:5;2839:3;2832:4;2824:6;2820:17;2816:27;2806:122;;2847:79;;:::i;:::-;2806:122;2964:6;2951:20;2989:94;3079:3;3071:6;3064:4;3056:6;3052:17;2989:94;:::i;:::-;2980:103;;2796:293;2719:370;;;;:::o;3095:320::-;3181:4;3271:18;3263:6;3260:30;3257:56;;;3293:18;;:::i;:::-;3257:56;3343:4;3335:6;3331:17;3323:25;;3403:4;3397;3393:15;3385:23;;3095:320;;;:::o;3421:117::-;3530:1;3527;3520:12;3544:307;3605:4;3695:18;3687:6;3684:30;3681:56;;;3717:18;;:::i;:::-;3681:56;3755:29;3777:6;3755:29;:::i;:::-;3747:37;;3839:4;3833;3829:15;3821:23;;3544:307;;;:::o;3857:148::-;3955:6;3950:3;3945;3932:30;3996:1;3987:6;3982:3;3978:16;3971:27;3857:148;;;:::o;4011:423::-;4088:5;4113:65;4129:48;4170:6;4129:48;:::i;:::-;4113:65;:::i;:::-;4104:74;;4201:6;4194:5;4187:21;4239:4;4232:5;4228:16;4277:3;4268:6;4263:3;4259:16;4256:25;4253:112;;;4284:79;;:::i;:::-;4253:112;4374:54;4421:6;4416:3;4411;4374:54;:::i;:::-;4094:340;4011:423;;;;;:::o;4453:338::-;4508:5;4557:3;4550:4;4542:6;4538:17;4534:27;4524:122;;4565:79;;:::i;:::-;4524:122;4682:6;4669:20;4707:78;4781:3;4773:6;4766:4;4758:6;4754:17;4707:78;:::i;:::-;4698:87;;4514:277;4453:338;;;;:::o;4812:942::-;4917:5;4942:90;4958:73;5024:6;4958:73;:::i;:::-;4942:90;:::i;:::-;4933:99;;5052:5;5081:6;5074:5;5067:21;5115:4;5108:5;5104:16;5097:23;;5168:4;5160:6;5156:17;5148:6;5144:30;5197:3;5189:6;5186:15;5183:122;;;5216:79;;:::i;:::-;5183:122;5331:6;5314:434;5348:6;5343:3;5340:15;5314:434;;;5437:3;5424:17;5473:18;5460:11;5457:35;5454:122;;;5495:79;;:::i;:::-;5454:122;5619:11;5611:6;5607:24;5657:46;5699:3;5687:10;5657:46;:::i;:::-;5652:3;5645:59;5733:4;5728:3;5724:14;5717:21;;5390:358;;5374:4;5369:3;5365:14;5358:21;;5314:434;;;5318:21;4923:831;;4812:942;;;;;:::o;5775:388::-;5855:5;5904:3;5897:4;5889:6;5885:17;5881:27;5871:122;;5912:79;;:::i;:::-;5871:122;6029:6;6016:20;6054:103;6153:3;6145:6;6138:4;6130:6;6126:17;6054:103;:::i;:::-;6045:112;;5861:302;5775:388;;;;:::o;6169:912::-;6296:6;6304;6353:2;6341:9;6332:7;6328:23;6324:32;6321:119;;;6359:79;;:::i;:::-;6321:119;6507:1;6496:9;6492:17;6479:31;6537:18;6529:6;6526:30;6523:117;;;6559:79;;:::i;:::-;6523:117;6664:78;6734:7;6725:6;6714:9;6710:22;6664:78;:::i;:::-;6654:88;;6450:302;6819:2;6808:9;6804:18;6791:32;6850:18;6842:6;6839:30;6836:117;;;6872:79;;:::i;:::-;6836:117;6977:87;7056:7;7047:6;7036:9;7032:22;6977:87;:::i;:::-;6967:97;;6762:312;6169:912;;;;;:::o;7087:118::-;7174:24;7192:5;7174:24;:::i;:::-;7169:3;7162:37;7087:118;;:::o;7211:222::-;7304:4;7342:2;7331:9;7327:18;7319:26;;7355:71;7423:1;7412:9;7408:17;7399:6;7355:71;:::i;:::-;7211:222;;;;:::o;7439:329::-;7498:6;7547:2;7535:9;7526:7;7522:23;7518:32;7515:119;;;7553:79;;:::i;:::-;7515:119;7673:1;7698:53;7743:7;7734:6;7723:9;7719:22;7698:53;:::i;:::-;7688:63;;7644:117;7439:329;;;;:::o;7774:98::-;7825:6;7859:5;7853:12;7843:22;;7774:98;;;:::o;7878:168::-;7961:11;7995:6;7990:3;7983:19;8035:4;8030:3;8026:14;8011:29;;7878:168;;;;:::o;8052:139::-;8141:6;8136:3;8131;8125:23;8182:1;8173:6;8168:3;8164:16;8157:27;8052:139;;;:::o;8197:373::-;8283:3;8311:38;8343:5;8311:38;:::i;:::-;8365:70;8428:6;8423:3;8365:70;:::i;:::-;8358:77;;8444:65;8502:6;8497:3;8490:4;8483:5;8479:16;8444:65;:::i;:::-;8534:29;8556:6;8534:29;:::i;:::-;8529:3;8525:39;8518:46;;8287:283;8197:373;;;;:::o;8576:309::-;8687:4;8725:2;8714:9;8710:18;8702:26;;8774:9;8768:4;8764:20;8760:1;8749:9;8745:17;8738:47;8802:76;8873:4;8864:6;8802:76;:::i;:::-;8794:84;;8576:309;;;;:::o;8891:334::-;8991:4;9081:18;9073:6;9070:30;9067:56;;;9103:18;;:::i;:::-;9067:56;9153:4;9145:6;9141:17;9133:25;;9213:4;9207;9203:15;9195:23;;8891:334;;;:::o;9231:117::-;9340:1;9337;9330:12;9354:117;9463:1;9460;9453:12;9477:308;9539:4;9629:18;9621:6;9618:30;9615:56;;;9651:18;;:::i;:::-;9615:56;9689:29;9711:6;9689:29;:::i;:::-;9681:37;;9773:4;9767;9763:15;9755:23;;9477:308;;;:::o;9791:425::-;9869:5;9894:66;9910:49;9952:6;9910:49;:::i;:::-;9894:66;:::i;:::-;9885:75;;9983:6;9976:5;9969:21;10021:4;10014:5;10010:16;10059:3;10050:6;10045:3;10041:16;10038:25;10035:112;;;10066:79;;:::i;:::-;10035:112;10156:54;10203:6;10198:3;10193;10156:54;:::i;:::-;9875:341;9791:425;;;;;:::o;10236:340::-;10292:5;10341:3;10334:4;10326:6;10322:17;10318:27;10308:122;;10349:79;;:::i;:::-;10308:122;10466:6;10453:20;10491:79;10566:3;10558:6;10551:4;10543:6;10539:17;10491:79;:::i;:::-;10482:88;;10298:278;10236:340;;;;:::o;10618:918::-;10690:5;10734:4;10722:9;10717:3;10713:19;10709:30;10706:117;;;10742:79;;:::i;:::-;10706:117;10841:21;10857:4;10841:21;:::i;:::-;10832:30;;10954:1;10943:9;10939:17;10926:31;10984:18;10976:6;10973:30;10970:117;;;11006:79;;:::i;:::-;10970:117;11126:59;11181:3;11172:6;11161:9;11157:22;11126:59;:::i;:::-;11119:4;11112:5;11108:16;11101:85;10872:325;11285:2;11274:9;11270:18;11257:32;11316:18;11308:6;11305:30;11302:117;;;11338:79;;:::i;:::-;11302:117;11458:59;11513:3;11504:6;11493:9;11489:22;11458:59;:::i;:::-;11451:4;11444:5;11440:16;11433:85;11207:322;10618:918;;;;:::o;11580:984::-;11699:5;11724:104;11740:87;11820:6;11740:87;:::i;:::-;11724:104;:::i;:::-;11715:113;;11848:5;11877:6;11870:5;11863:21;11911:4;11904:5;11900:16;11893:23;;11964:4;11956:6;11952:17;11944:6;11940:30;11993:3;11985:6;11982:15;11979:122;;;12012:79;;:::i;:::-;11979:122;12127:6;12110:448;12144:6;12139:3;12136:15;12110:448;;;12233:3;12220:17;12269:18;12256:11;12253:35;12250:122;;;12291:79;;:::i;:::-;12250:122;12415:11;12407:6;12403:24;12453:60;12509:3;12497:10;12453:60;:::i;:::-;12448:3;12441:73;12543:4;12538:3;12534:14;12527:21;;12186:372;;12170:4;12165:3;12161:14;12154:21;;12110:448;;;12114:21;11705:859;;11580:984;;;;;:::o;12608:416::-;12702:5;12751:3;12744:4;12736:6;12732:17;12728:27;12718:122;;12759:79;;:::i;:::-;12718:122;12876:6;12863:20;12901:117;13014:3;13006:6;12999:4;12991:6;12987:17;12901:117;:::i;:::-;12892:126;;12708:316;12608:416;;;;:::o;13030:730::-;13146:6;13154;13203:2;13191:9;13182:7;13178:23;13174:32;13171:119;;;13209:79;;:::i;:::-;13171:119;13329:1;13354:53;13399:7;13390:6;13379:9;13375:22;13354:53;:::i;:::-;13344:63;;13300:117;13484:2;13473:9;13469:18;13456:32;13515:18;13507:6;13504:30;13501:117;;;13537:79;;:::i;:::-;13501:117;13642:101;13735:7;13726:6;13715:9;13711:22;13642:101;:::i;:::-;13632:111;;13427:326;13030:730;;;;;:::o;13766:126::-;13803:7;13843:42;13836:5;13832:54;13821:65;;13766:126;;;:::o;13898:96::-;13935:7;13964:24;13982:5;13964:24;:::i;:::-;13953:35;;13898:96;;;:::o;14000:122::-;14073:24;14091:5;14073:24;:::i;:::-;14066:5;14063:35;14053:63;;14112:1;14109;14102:12;14053:63;14000:122;:::o;14128:139::-;14174:5;14212:6;14199:20;14190:29;;14228:33;14255:5;14228:33;:::i;:::-;14128:139;;;;:::o;14273:329::-;14332:6;14381:2;14369:9;14360:7;14356:23;14352:32;14349:119;;;14387:79;;:::i;:::-;14349:119;14507:1;14532:53;14577:7;14568:6;14557:9;14553:22;14532:53;:::i;:::-;14522:63;;14478:117;14273:329;;;;:::o;14608:765::-;14694:6;14702;14710;14718;14767:3;14755:9;14746:7;14742:23;14738:33;14735:120;;;14774:79;;:::i;:::-;14735:120;14894:1;14919:53;14964:7;14955:6;14944:9;14940:22;14919:53;:::i;:::-;14909:63;;14865:117;15021:2;15047:53;15092:7;15083:6;15072:9;15068:22;15047:53;:::i;:::-;15037:63;;14992:118;15149:2;15175:53;15220:7;15211:6;15200:9;15196:22;15175:53;:::i;:::-;15165:63;;15120:118;15277:2;15303:53;15348:7;15339:6;15328:9;15324:22;15303:53;:::i;:::-;15293:63;;15248:118;14608:765;;;;;;;:::o;15379:553::-;15556:4;15594:3;15583:9;15579:19;15571:27;;15608:71;15676:1;15665:9;15661:17;15652:6;15608:71;:::i;:::-;15689:72;15757:2;15746:9;15742:18;15733:6;15689:72;:::i;:::-;15771;15839:2;15828:9;15824:18;15815:6;15771:72;:::i;:::-;15853;15921:2;15910:9;15906:18;15897:6;15853:72;:::i;:::-;15379:553;;;;;;;:::o;15938:104::-;15983:7;16012:24;16030:5;16012:24;:::i;:::-;16001:35;;15938:104;;;:::o;16048:142::-;16151:32;16177:5;16151:32;:::i;:::-;16146:3;16139:45;16048:142;;:::o;16196:254::-;16305:4;16343:2;16332:9;16328:18;16320:26;;16356:87;16440:1;16429:9;16425:17;16416:6;16356:87;:::i;:::-;16196:254;;;;:::o;16456:652::-;16533:6;16541;16590:2;16578:9;16569:7;16565:23;16561:32;16558:119;;;16596:79;;:::i;:::-;16558:119;16716:1;16741:53;16786:7;16777:6;16766:9;16762:22;16741:53;:::i;:::-;16731:63;;16687:117;16871:2;16860:9;16856:18;16843:32;16902:18;16894:6;16891:30;16888:117;;;16924:79;;:::i;:::-;16888:117;17029:62;17083:7;17074:6;17063:9;17059:22;17029:62;:::i;:::-;17019:72;;16814:287;16456:652;;;;;:::o;17114:359::-;17239:4;17329:18;17321:6;17318:30;17315:56;;;17351:18;;:::i;:::-;17315:56;17401:4;17393:6;17389:17;17381:25;;17461:4;17455;17451:15;17443:23;;17114:359;;;:::o;17519:1059::-;17663:5;17688:129;17704:112;17809:6;17704:112;:::i;:::-;17688:129;:::i;:::-;17679:138;;17837:5;17866:6;17859:5;17852:21;17900:4;17893:5;17889:16;17882:23;;17953:4;17945:6;17941:17;17933:6;17929:30;17982:3;17974:6;17971:15;17968:122;;;18001:79;;:::i;:::-;17968:122;18116:6;18099:473;18133:6;18128:3;18125:15;18099:473;;;18222:3;18209:17;18258:18;18245:11;18242:35;18239:122;;;18280:79;;:::i;:::-;18239:122;18404:11;18396:6;18392:24;18442:85;18523:3;18511:10;18442:85;:::i;:::-;18437:3;18430:98;18557:4;18552:3;18548:14;18541:21;;18175:397;;18159:4;18154:3;18150:14;18143:21;;18099:473;;;18103:21;17669:909;;17519:1059;;;;;:::o;18624:466::-;18743:5;18792:3;18785:4;18777:6;18773:17;18769:27;18759:122;;18800:79;;:::i;:::-;18759:122;18917:6;18904:20;18942:142;19080:3;19072:6;19065:4;19057:6;19053:17;18942:142;:::i;:::-;18933:151;;18749:341;18624:466;;;;:::o;19096:990::-;19262:6;19270;19319:2;19307:9;19298:7;19294:23;19290:32;19287:119;;;19325:79;;:::i;:::-;19287:119;19473:1;19462:9;19458:17;19445:31;19503:18;19495:6;19492:30;19489:117;;;19525:79;;:::i;:::-;19489:117;19630:78;19700:7;19691:6;19680:9;19676:22;19630:78;:::i;:::-;19620:88;;19416:302;19785:2;19774:9;19770:18;19757:32;19816:18;19808:6;19805:30;19802:117;;;19838:79;;:::i;:::-;19802:117;19943:126;20061:7;20052:6;20041:9;20037:22;19943:126;:::i;:::-;19933:136;;19728:351;19096:990;;;;;:::o;20092:99::-;20144:6;20178:5;20172:12;20162:22;;20092:99;;;:::o;20197:169::-;20281:11;20315:6;20310:3;20303:19;20355:4;20350:3;20346:14;20331:29;;20197:169;;;;:::o;20372:377::-;20460:3;20488:39;20521:5;20488:39;:::i;:::-;20543:71;20607:6;20602:3;20543:71;:::i;:::-;20536:78;;20623:65;20681:6;20676:3;20669:4;20662:5;20658:16;20623:65;:::i;:::-;20713:29;20735:6;20713:29;:::i;:::-;20708:3;20704:39;20697:46;;20464:285;20372:377;;;;:::o;20755:313::-;20868:4;20906:2;20895:9;20891:18;20883:26;;20955:9;20949:4;20945:20;20941:1;20930:9;20926:17;20919:47;20983:78;21056:4;21047:6;20983:78;:::i;:::-;20975:86;;20755:313;;;;:::o;21074:979::-;21171:6;21179;21187;21236:2;21224:9;21215:7;21211:23;21207:32;21204:119;;;21242:79;;:::i;:::-;21204:119;21362:1;21387:53;21432:7;21423:6;21412:9;21408:22;21387:53;:::i;:::-;21377:63;;21333:117;21517:2;21506:9;21502:18;21489:32;21548:18;21540:6;21537:30;21534:117;;;21570:79;;:::i;:::-;21534:117;21675:63;21730:7;21721:6;21710:9;21706:22;21675:63;:::i;:::-;21665:73;;21460:288;21815:2;21804:9;21800:18;21787:32;21846:18;21838:6;21835:30;21832:117;;;21868:79;;:::i;:::-;21832:117;21973:63;22028:7;22019:6;22008:9;22004:22;21973:63;:::i;:::-;21963:73;;21758:288;21074:979;;;;;:::o;22059:164::-;22199:16;22195:1;22187:6;22183:14;22176:40;22059:164;:::o;22229:366::-;22371:3;22392:67;22456:2;22451:3;22392:67;:::i;:::-;22385:74;;22468:93;22557:3;22468:93;:::i;:::-;22586:2;22581:3;22577:12;22570:19;;22229:366;;;:::o;22601:419::-;22767:4;22805:2;22794:9;22790:18;22782:26;;22854:9;22848:4;22844:20;22840:1;22829:9;22825:17;22818:47;22882:131;23008:4;22882:131;:::i;:::-;22874:139;;22601:419;;;:::o;23026:169::-;23166:21;23162:1;23154:6;23150:14;23143:45;23026:169;:::o;23201:366::-;23343:3;23364:67;23428:2;23423:3;23364:67;:::i;:::-;23357:74;;23440:93;23529:3;23440:93;:::i;:::-;23558:2;23553:3;23549:12;23542:19;;23201:366;;;:::o;23573:419::-;23739:4;23777:2;23766:9;23762:18;23754:26;;23826:9;23820:4;23816:20;23812:1;23801:9;23797:17;23790:47;23854:131;23980:4;23854:131;:::i;:::-;23846:139;;23573:419;;;:::o;23998:167::-;24138:19;24134:1;24126:6;24122:14;24115:43;23998:167;:::o;24171:366::-;24313:3;24334:67;24398:2;24393:3;24334:67;:::i;:::-;24327:74;;24410:93;24499:3;24410:93;:::i;:::-;24528:2;24523:3;24519:12;24512:19;;24171:366;;;:::o;24543:419::-;24709:4;24747:2;24736:9;24732:18;24724:26;;24796:9;24790:4;24786:20;24782:1;24771:9;24767:17;24760:47;24824:131;24950:4;24824:131;:::i;:::-;24816:139;;24543:419;;;:::o;24968:180::-;25016:77;25013:1;25006:88;25113:4;25110:1;25103:15;25137:4;25134:1;25127:15;25154:165;25294:17;25290:1;25282:6;25278:14;25271:41;25154:165;:::o;25325:366::-;25467:3;25488:67;25552:2;25547:3;25488:67;:::i;:::-;25481:74;;25564:93;25653:3;25564:93;:::i;:::-;25682:2;25677:3;25673:12;25666:19;;25325:366;;;:::o;25697:419::-;25863:4;25901:2;25890:9;25886:18;25878:26;;25950:9;25944:4;25940:20;25936:1;25925:9;25921:17;25914:47;25978:131;26104:4;25978:131;:::i;:::-;25970:139;;25697:419;;;:::o;26122:180::-;26170:77;26167:1;26160:88;26267:4;26264:1;26257:15;26291:4;26288:1;26281:15;26308:410;26348:7;26371:20;26389:1;26371:20;:::i;:::-;26366:25;;26405:20;26423:1;26405:20;:::i;:::-;26400:25;;26460:1;26457;26453:9;26482:30;26500:11;26482:30;:::i;:::-;26471:41;;26661:1;26652:7;26648:15;26645:1;26642:22;26622:1;26615:9;26595:83;26572:139;;26691:18;;:::i;:::-;26572:139;26356:362;26308:410;;;;:::o;26724:175::-;26864:27;26860:1;26852:6;26848:14;26841:51;26724:175;:::o;26905:366::-;27047:3;27068:67;27132:2;27127:3;27068:67;:::i;:::-;27061:74;;27144:93;27233:3;27144:93;:::i;:::-;27262:2;27257:3;27253:12;27246:19;;26905:366;;;:::o;27277:419::-;27443:4;27481:2;27470:9;27466:18;27458:26;;27530:9;27524:4;27520:20;27516:1;27505:9;27501:17;27494:47;27558:131;27684:4;27558:131;:::i;:::-;27550:139;;27277:419;;;:::o;27702:180::-;27750:77;27747:1;27740:88;27847:4;27844:1;27837:15;27871:4;27868:1;27861:15;27888:320;27932:6;27969:1;27963:4;27959:12;27949:22;;28016:1;28010:4;28006:12;28037:18;28027:81;;28093:4;28085:6;28081:17;28071:27;;28027:81;28155:2;28147:6;28144:14;28124:18;28121:38;28118:84;;28174:18;;:::i;:::-;28118:84;27939:269;27888:320;;;:::o;28214:140::-;28262:4;28285:3;28277:11;;28308:3;28305:1;28298:14;28342:4;28339:1;28329:18;28321:26;;28214:140;;;:::o;28360:93::-;28397:6;28444:2;28439;28432:5;28428:14;28424:23;28414:33;;28360:93;;;:::o;28459:107::-;28503:8;28553:5;28547:4;28543:16;28522:37;;28459:107;;;;:::o;28572:393::-;28641:6;28691:1;28679:10;28675:18;28714:97;28744:66;28733:9;28714:97;:::i;:::-;28832:39;28862:8;28851:9;28832:39;:::i;:::-;28820:51;;28904:4;28900:9;28893:5;28889:21;28880:30;;28953:4;28943:8;28939:19;28932:5;28929:30;28919:40;;28648:317;;28572:393;;;;;:::o;28971:60::-;28999:3;29020:5;29013:12;;28971:60;;;:::o;29037:142::-;29087:9;29120:53;29138:34;29147:24;29165:5;29147:24;:::i;:::-;29138:34;:::i;:::-;29120:53;:::i;:::-;29107:66;;29037:142;;;:::o;29185:75::-;29228:3;29249:5;29242:12;;29185:75;;;:::o;29266:269::-;29376:39;29407:7;29376:39;:::i;:::-;29437:91;29486:41;29510:16;29486:41;:::i;:::-;29478:6;29471:4;29465:11;29437:91;:::i;:::-;29431:4;29424:105;29342:193;29266:269;;;:::o;29541:73::-;29586:3;29541:73;:::o;29620:189::-;29697:32;;:::i;:::-;29738:65;29796:6;29788;29782:4;29738:65;:::i;:::-;29673:136;29620:189;;:::o;29815:186::-;29875:120;29892:3;29885:5;29882:14;29875:120;;;29946:39;29983:1;29976:5;29946:39;:::i;:::-;29919:1;29912:5;29908:13;29899:22;;29875:120;;;29815:186;;:::o;30007:541::-;30107:2;30102:3;30099:11;30096:445;;;30141:37;30172:5;30141:37;:::i;:::-;30224:29;30242:10;30224:29;:::i;:::-;30214:8;30210:44;30407:2;30395:10;30392:18;30389:49;;;30428:8;30413:23;;30389:49;30451:80;30507:22;30525:3;30507:22;:::i;:::-;30497:8;30493:37;30480:11;30451:80;:::i;:::-;30111:430;;30096:445;30007:541;;;:::o;30554:117::-;30608:8;30658:5;30652:4;30648:16;30627:37;;30554:117;;;;:::o;30677:169::-;30721:6;30754:51;30802:1;30798:6;30790:5;30787:1;30783:13;30754:51;:::i;:::-;30750:56;30835:4;30829;30825:15;30815:25;;30728:118;30677:169;;;;:::o;30851:295::-;30927:4;31073:29;31098:3;31092:4;31073:29;:::i;:::-;31065:37;;31135:3;31132:1;31128:11;31122:4;31119:21;31111:29;;30851:295;;;;:::o;31151:1390::-;31266:36;31298:3;31266:36;:::i;:::-;31367:18;31359:6;31356:30;31353:56;;;31389:18;;:::i;:::-;31353:56;31433:38;31465:4;31459:11;31433:38;:::i;:::-;31518:66;31577:6;31569;31563:4;31518:66;:::i;:::-;31611:1;31635:4;31622:17;;31667:2;31659:6;31656:14;31684:1;31679:617;;;;32340:1;32357:6;32354:77;;;32406:9;32401:3;32397:19;32391:26;32382:35;;32354:77;32457:67;32517:6;32510:5;32457:67;:::i;:::-;32451:4;32444:81;32313:222;31649:886;;31679:617;31731:4;31727:9;31719:6;31715:22;31765:36;31796:4;31765:36;:::i;:::-;31823:1;31837:208;31851:7;31848:1;31845:14;31837:208;;;31930:9;31925:3;31921:19;31915:26;31907:6;31900:42;31981:1;31973:6;31969:14;31959:24;;32028:2;32017:9;32013:18;32000:31;;31874:4;31871:1;31867:12;31862:17;;31837:208;;;32073:6;32064:7;32061:19;32058:179;;;32131:9;32126:3;32122:19;32116:26;32174:48;32216:4;32208:6;32204:17;32193:9;32174:48;:::i;:::-;32166:6;32159:64;32081:156;32058:179;32283:1;32279;32271:6;32267:14;32263:22;32257:4;32250:36;31686:610;;;31649:886;;31241:1300;;;31151:1390;;:::o;32547:167::-;32687:19;32683:1;32675:6;32671:14;32664:43;32547:167;:::o;32720:366::-;32862:3;32883:67;32947:2;32942:3;32883:67;:::i;:::-;32876:74;;32959:93;33048:3;32959:93;:::i;:::-;33077:2;33072:3;33068:12;33061:19;;32720:366;;;:::o;33092:419::-;33258:4;33296:2;33285:9;33281:18;33273:26;;33345:9;33339:4;33335:20;33331:1;33320:9;33316:17;33309:47;33373:131;33499:4;33373:131;:::i;:::-;33365:139;;33092:419;;;:::o;33517:191::-;33557:3;33576:20;33594:1;33576:20;:::i;:::-;33571:25;;33610:20;33628:1;33610:20;:::i;:::-;33605:25;;33653:1;33650;33646:9;33639:16;;33674:3;33671:1;33668:10;33665:36;;;33681:18;;:::i;:::-;33665:36;33517:191;;;;:::o;33714:172::-;33854:24;33850:1;33842:6;33838:14;33831:48;33714:172;:::o;33892:366::-;34034:3;34055:67;34119:2;34114:3;34055:67;:::i;:::-;34048:74;;34131:93;34220:3;34131:93;:::i;:::-;34249:2;34244:3;34240:12;34233:19;;33892:366;;;:::o;34264:419::-;34430:4;34468:2;34457:9;34453:18;34445:26;;34517:9;34511:4;34507:20;34503:1;34492:9;34488:17;34481:47;34545:131;34671:4;34545:131;:::i;:::-;34537:139;;34264:419;;;:::o;34689:141::-;34738:4;34761:3;34753:11;;34784:3;34781:1;34774:14;34818:4;34815:1;34805:18;34797:26;;34689:141;;;:::o;34836:543::-;34937:2;34932:3;34929:11;34926:446;;;34971:38;35003:5;34971:38;:::i;:::-;35055:29;35073:10;35055:29;:::i;:::-;35045:8;35041:44;35238:2;35226:10;35223:18;35220:49;;;35259:8;35244:23;;35220:49;35282:80;35338:22;35356:3;35338:22;:::i;:::-;35328:8;35324:37;35311:11;35282:80;:::i;:::-;34941:431;;34926:446;34836:543;;;:::o;35385:1395::-;35502:37;35535:3;35502:37;:::i;:::-;35604:18;35596:6;35593:30;35590:56;;;35626:18;;:::i;:::-;35590:56;35670:38;35702:4;35696:11;35670:38;:::i;:::-;35755:67;35815:6;35807;35801:4;35755:67;:::i;:::-;35849:1;35873:4;35860:17;;35905:2;35897:6;35894:14;35922:1;35917:618;;;;36579:1;36596:6;36593:77;;;36645:9;36640:3;36636:19;36630:26;36621:35;;36593:77;36696:67;36756:6;36749:5;36696:67;:::i;:::-;36690:4;36683:81;36552:222;35887:887;;35917:618;35969:4;35965:9;35957:6;35953:22;36003:37;36035:4;36003:37;:::i;:::-;36062:1;36076:208;36090:7;36087:1;36084:14;36076:208;;;36169:9;36164:3;36160:19;36154:26;36146:6;36139:42;36220:1;36212:6;36208:14;36198:24;;36267:2;36256:9;36252:18;36239:31;;36113:4;36110:1;36106:12;36101:17;;36076:208;;;36312:6;36303:7;36300:19;36297:179;;;36370:9;36365:3;36361:19;36355:26;36413:48;36455:4;36447:6;36443:17;36432:9;36413:48;:::i;:::-;36405:6;36398:64;36320:156;36297:179;36522:1;36518;36510:6;36506:14;36502:22;36496:4;36489:36;35924:611;;;35887:887;;35477:1303;;;35385:1395;;:::o;36786:169::-;36926:21;36922:1;36914:6;36910:14;36903:45;36786:169;:::o;36961:366::-;37103:3;37124:67;37188:2;37183:3;37124:67;:::i;:::-;37117:74;;37200:93;37289:3;37200:93;:::i;:::-;37318:2;37313:3;37309:12;37302:19;;36961:366;;;:::o;37333:419::-;37499:4;37537:2;37526:9;37522:18;37514:26;;37586:9;37580:4;37576:20;37572:1;37561:9;37557:17;37550:47;37614:131;37740:4;37614:131;:::i;:::-;37606:139;;37333:419;;;:::o;37758:170::-;37898:22;37894:1;37886:6;37882:14;37875:46;37758:170;:::o;37934:366::-;38076:3;38097:67;38161:2;38156:3;38097:67;:::i;:::-;38090:74;;38173:93;38262:3;38173:93;:::i;:::-;38291:2;38286:3;38282:12;38275:19;;37934:366;;;:::o;38306:419::-;38472:4;38510:2;38499:9;38495:18;38487:26;;38559:9;38553:4;38549:20;38545:1;38534:9;38530:17;38523:47;38587:131;38713:4;38587:131;:::i;:::-;38579:139;;38306:419;;;:::o;38731:181::-;38871:33;38867:1;38859:6;38855:14;38848:57;38731:181;:::o;38918:366::-;39060:3;39081:67;39145:2;39140:3;39081:67;:::i;:::-;39074:74;;39157:93;39246:3;39157:93;:::i;:::-;39275:2;39270:3;39266:12;39259:19;;38918:366;;;:::o;39290:419::-;39456:4;39494:2;39483:9;39479:18;39471:26;;39543:9;39537:4;39533:20;39529:1;39518:9;39514:17;39507:47;39571:131;39697:4;39571:131;:::i;:::-;39563:139;;39290:419;;;:::o;39715:164::-;39855:16;39851:1;39843:6;39839:14;39832:40;39715:164;:::o;39885:366::-;40027:3;40048:67;40112:2;40107:3;40048:67;:::i;:::-;40041:74;;40124:93;40213:3;40124:93;:::i;:::-;40242:2;40237:3;40233:12;40226:19;;39885:366;;;:::o;40257:419::-;40423:4;40461:2;40450:9;40446:18;40438:26;;40510:9;40504:4;40500:20;40496:1;40485:9;40481:17;40474:47;40538:131;40664:4;40538:131;:::i;:::-;40530:139;;40257:419;;;:::o;40682:147::-;40783:11;40820:3;40805:18;;40682:147;;;;:::o;40835:386::-;40939:3;40967:38;40999:5;40967:38;:::i;:::-;41021:88;41102:6;41097:3;41021:88;:::i;:::-;41014:95;;41118:65;41176:6;41171:3;41164:4;41157:5;41153:16;41118:65;:::i;:::-;41208:6;41203:3;41199:16;41192:23;;40943:278;40835:386;;;;:::o;41227:148::-;41329:11;41366:3;41351:18;;41227:148;;;;:::o;41381:214::-;41521:66;41517:1;41509:6;41505:14;41498:90;41381:214;:::o;41601:402::-;41761:3;41782:85;41864:2;41859:3;41782:85;:::i;:::-;41775:92;;41876:93;41965:3;41876:93;:::i;:::-;41994:2;41989:3;41985:12;41978:19;;41601:402;;;:::o;42033:874::-;42136:3;42173:5;42167:12;42202:36;42228:9;42202:36;:::i;:::-;42254:89;42336:6;42331:3;42254:89;:::i;:::-;42247:96;;42374:1;42363:9;42359:17;42390:1;42385:166;;;;42565:1;42560:341;;;;42352:549;;42385:166;42469:4;42465:9;42454;42450:25;42445:3;42438:38;42531:6;42524:14;42517:22;42509:6;42505:35;42500:3;42496:45;42489:52;;42385:166;;42560:341;42627:38;42659:5;42627:38;:::i;:::-;42687:1;42701:154;42715:6;42712:1;42709:13;42701:154;;;42789:7;42783:14;42779:1;42774:3;42770:11;42763:35;42839:1;42830:7;42826:15;42815:26;;42737:4;42734:1;42730:12;42725:17;;42701:154;;;42884:6;42879:3;42875:16;42868:23;;42567:334;;42352:549;;42140:767;;42033:874;;;;:::o;42913:214::-;43053:66;43049:1;43041:6;43037:14;43030:90;42913:214;:::o;43133:402::-;43293:3;43314:85;43396:2;43391:3;43314:85;:::i;:::-;43307:92;;43408:93;43497:3;43408:93;:::i;:::-;43526:2;43521:3;43517:12;43510:19;;43133:402;;;:::o;43541:214::-;43681:66;43677:1;43669:6;43665:14;43658:90;43541:214;:::o;43761:400::-;43921:3;43942:84;44024:1;44019:3;43942:84;:::i;:::-;43935:91;;44035:93;44124:3;44035:93;:::i;:::-;44153:1;44148:3;44144:11;44137:18;;43761:400;;;:::o;44167:1377::-;44690:3;44712:93;44801:3;44792:6;44712:93;:::i;:::-;44705:100;;44822:148;44966:3;44822:148;:::i;:::-;44815:155;;44987:92;45075:3;45066:6;44987:92;:::i;:::-;44980:99;;45096:148;45240:3;45096:148;:::i;:::-;45089:155;;45261:92;45349:3;45340:6;45261:92;:::i;:::-;45254:99;;45370:148;45514:3;45370:148;:::i;:::-;45363:155;;45535:3;45528:10;;44167:1377;;;;;;:::o;45550:194::-;45590:4;45610:20;45628:1;45610:20;:::i;:::-;45605:25;;45644:20;45662:1;45644:20;:::i;:::-;45639:25;;45688:1;45685;45681:9;45673:17;;45712:1;45706:4;45703:11;45700:37;;;45717:18;;:::i;:::-;45700:37;45550:194;;;;:::o;45750:151::-;45890:3;45886:1;45878:6;45874:14;45867:27;45750:151;:::o;45907:400::-;46067:3;46088:84;46170:1;46165:3;46088:84;:::i;:::-;46081:91;;46181:93;46270:3;46181:93;:::i;:::-;46299:1;46294:3;46290:11;46283:18;;45907:400;;;:::o;46313:537::-;46544:3;46566:93;46655:3;46646:6;46566:93;:::i;:::-;46559:100;;46676:148;46820:3;46676:148;:::i;:::-;46669:155;;46841:3;46834:10;;46313:537;;;;:::o;46856:214::-;46996:66;46992:1;46984:6;46980:14;46973:90;46856:214;:::o;47076:402::-;47236:3;47257:85;47339:2;47334:3;47257:85;:::i;:::-;47250:92;;47351:93;47440:3;47351:93;:::i;:::-;47469:2;47464:3;47460:12;47453:19;;47076:402;;;:::o;47484:390::-;47590:3;47618:39;47651:5;47618:39;:::i;:::-;47673:89;47755:6;47750:3;47673:89;:::i;:::-;47666:96;;47771:65;47829:6;47824:3;47817:4;47810:5;47806:16;47771:65;:::i;:::-;47861:6;47856:3;47852:16;47845:23;;47594:280;47484:390;;;;:::o;47880:963::-;48260:3;48282:93;48371:3;48362:6;48282:93;:::i;:::-;48275:100;;48392:148;48536:3;48392:148;:::i;:::-;48385:155;;48557:95;48648:3;48639:6;48557:95;:::i;:::-;48550:102;;48669:148;48813:3;48669:148;:::i;:::-;48662:155;;48834:3;48827:10;;47880:963;;;;;:::o;48849:315::-;48989:66;48985:1;48977:6;48973:14;48966:90;49090:66;49085:2;49077:6;49073:15;49066:91;48849:315;:::o;49170:402::-;49330:3;49351:85;49433:2;49428:3;49351:85;:::i;:::-;49344:92;;49445:93;49534:3;49445:93;:::i;:::-;49563:2;49558:3;49554:12;49547:19;;49170:402;;;:::o;49578:214::-;49718:66;49714:1;49706:6;49702:14;49695:90;49578:214;:::o;49798:400::-;49958:3;49979:84;50061:1;50056:3;49979:84;:::i;:::-;49972:91;;50072:93;50161:3;50072:93;:::i;:::-;50190:1;50185:3;50181:11;50174:18;;49798:400;;;:::o;50204:963::-;50584:3;50606:93;50695:3;50686:6;50606:93;:::i;:::-;50599:100;;50716:148;50860:3;50716:148;:::i;:::-;50709:155;;50881:95;50972:3;50963:6;50881:95;:::i;:::-;50874:102;;50993:148;51137:3;50993:148;:::i;:::-;50986:155;;51158:3;51151:10;;50204:963;;;;;:::o;51173:144::-;51225:4;51248:3;51240:11;;51271:3;51268:1;51261:14;51305:4;51302:1;51292:18;51284:26;;51173:144;;;:::o;51345:878::-;51450:3;51487:5;51481:12;51516:36;51542:9;51516:36;:::i;:::-;51568:88;51649:6;51644:3;51568:88;:::i;:::-;51561:95;;51687:1;51676:9;51672:17;51703:1;51698:166;;;;51878:1;51873:344;;;;51665:552;;51698:166;51782:4;51778:9;51767;51763:25;51758:3;51751:38;51844:6;51837:14;51830:22;51822:6;51818:35;51813:3;51809:45;51802:52;;51698:166;;51873:344;51940:41;51975:5;51940:41;:::i;:::-;52003:1;52017:154;52031:6;52028:1;52025:13;52017:154;;;52105:7;52099:14;52095:1;52090:3;52086:11;52079:35;52155:1;52146:7;52142:15;52131:26;;52053:4;52050:1;52046:12;52041:17;;52017:154;;;52200:6;52195:3;52191:16;52184:23;;51880:337;;51665:552;;51454:769;;51345:878;;;;:::o;52229:273::-;52360:3;52382:94;52472:3;52463:6;52382:94;:::i;:::-;52375:101;;52493:3;52486:10;;52229:273;;;;:::o;52508:168::-;52648:20;52644:1;52636:6;52632:14;52625:44;52508:168;:::o;52682:366::-;52824:3;52845:67;52909:2;52904:3;52845:67;:::i;:::-;52838:74;;52921:93;53010:3;52921:93;:::i;:::-;53039:2;53034:3;53030:12;53023:19;;52682:366;;;:::o;53054:419::-;53220:4;53258:2;53247:9;53243:18;53235:26;;53307:9;53301:4;53297:20;53293:1;53282:9;53278:17;53271:47;53335:131;53461:4;53335:131;:::i;:::-;53327:139;;53054:419;;;:::o;53479:180::-;53527:77;53524:1;53517:88;53624:4;53621:1;53614:15;53648:4;53645:1;53638:15

ipfs://2fb1be5b17f96863759a317f91652c054aec521597f0837737af91eab060399e