Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC1155Errors interface IERC20Errors interface IERC721Errors interface IERC1155Receiver    - function onERC1155Received(    - function onERC1155BatchReceived( library ERC1155Utils    - function checkOnERC1155Received(    - function checkOnERC1155BatchReceived( library SafeMath    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function add(uint256 a, uint256 b) library StorageSlot    - function getAddressSlot(bytes32 slot)    - function getBooleanSlot(bytes32 slot)    - function getBytes32Slot(bytes32 slot)    - function getUint256Slot(bytes32 slot)    - function getStringSlot(bytes32 slot)    - function getStringSlot(string storage ...    - function getBytesSlot(bytes32 slot)    - function getBytesSlot(bytes storage s ... library Math    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ...    - function unsignedRoundsUp(Rounding ro ... library Arrays    - function findUpperBound(uint256[] sto ...    - function unsafeAccess(address[] stora ...    - function unsafeAccess(bytes32[] stora ...    - function unsafeAccess(uint256[] stora ...    - function unsafeMemoryAccess(uint256[] ...    - function unsafeMemoryAccess(address[] ... library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Strings    - function toString(uint256 value)    - function toString(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ...    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ...  contract ERC11 is Ownable    - function isInAllowlist(address target ...    - function setAllowList(address target, ...    - function balanceOf(address account, u ...    - function balanceOfBatch(address[] cal ...    - function isApprovedForAll(address acc ...    - function safeTransferFrom(    - function safeBatchTransferFrom(    - function setApprovalForAll(address op ...    - function _nft_update(    - function _nft_burn(    - function _nft_mint(    - function _safeTransferFrom(    - function _safeBatchTransferFrom(    - function _asSingletonArrays(uint256 e ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function increaseAllowance(address _s ...    - function decreaseAllowance(address _s ...    - function transferFrom(    - function _transfer(    - function _update(    - function _mint(address account, uint2 ...    - function mint(address account, uint25 ...    - function burn(uint256 value)    - function _burn(address account, uint2 ...    - function _approve(    - function _approve(    - function _spendAllowance(  contract Groge is ERC11 *    - function setURI(string memory newURI)    - function uri(uint256 _tokenId)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-05-27
*/

// SPDX-License-Identifier: MIT

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed,
        uint256 tokenId
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(
        address spender,
        uint256 allowance,
        uint256 needed
    );

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */

/**
    Note: The ERC-165 identifier for this interface is 0x4e2312e0.
*/
interface IERC1155Receiver {
    /**
        @notice Handle the receipt of a single ERC1155 token type.
        @dev An ERC1155-compliant smart contract MUST call this function on the token recipient contract, at the end of a `safeTransferFrom` after the balance has been updated.
        This function MUST return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61) if it accepts the transfer.
        This function MUST revert if it rejects the transfer.
        Return of any other value than the prescribed keccak256 generated value MUST result in the transaction being reverted by the caller.
        @param _operator  The address which initiated the transfer (i.e. msg.sender)
        @param _from      The address which previously owned the token
        @param _id        The ID of the token being transferred
        @param _value     The amount of tokens being transferred
        @param _data      Additional data with no specified format
        @return           `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
    */
    function onERC1155Received(
        address _operator,
        address _from,
        uint256 _id,
        uint256 _value,
        bytes calldata _data
    ) external returns (bytes4);

    /**
        @notice Handle the receipt of multiple ERC1155 token types.
        @dev An ERC1155-compliant smart contract MUST call this function on the token recipient contract, at the end of a `safeBatchTransferFrom` after the balances have been updated.
        This function MUST return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81) if it accepts the transfer(s).
        This function MUST revert if it rejects the transfer(s).
        Return of any other value than the prescribed keccak256 generated value MUST result in the transaction being reverted by the caller.
        @param _operator  The address which initiated the batch transfer (i.e. msg.sender)
        @param _from      The address which previously owned the token
        @param _ids       An array containing ids of each token being transferred (order and length must match _values array)
        @param _values    An array containing amounts of each token being transferred (order and length must match _ids array)
        @param _data      Additional data with no specified format
        @return           `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
    */
    function onERC1155BatchReceived(
        address _operator,
        address _from,
        uint256[] calldata _ids,
        uint256[] calldata _values,
        bytes calldata _data
    ) external returns (bytes4);
}

pragma solidity ^0.8.20;

/**
 * @dev Library that provide common ERC-1155 utility functions.
 *
 * See https://eips.ethereum.org/EIPS/eip-1155[ERC-1155].
 */
library ERC1155Utils {
    /**
     * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address is doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC1155Received(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length > 0) {
            try
                IERC1155Receiver(to).onERC1155Received(
                    operator,
                    from,
                    id,
                    value,
                    data
                )
            returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC1155Receiver implementer
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address is doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC1155BatchReceived(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        if (to.code.length > 0) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    values,
                    data
                )
            returns (bytes4 response) {
                if (
                    response != IERC1155Receiver.onERC1155BatchReceived.selector
                ) {
                    // Tokens rejected
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC1155Receiver implementer
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
pragma solidity ^0.8.20;

library SafeMath {
    /**
     * @dev Multiplies two numbers, throws on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        if (a == 0) {
            return 0;
        }
        c = a * b;
        assert(c / a == b);
        return c;
    }

    /**
     * @dev Integer division of two numbers, truncating the quotient.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        // uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return a / b;
    }

    /**
     * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }

    /**
     * @dev Adds two numbers, throws on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = a + b;
        assert(c >= a);
        return c;
    }
}

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

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

pragma solidity ^0.8.20;

library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot)
        internal
        pure
        returns (AddressSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot)
        internal
        pure
        returns (BooleanSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot)
        internal
        pure
        returns (Bytes32Slot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot)
        internal
        pure
        returns (Uint256Slot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot)
        internal
        pure
        returns (StringSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store)
        internal
        pure
        returns (StringSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot)
        internal
        pure
        returns (BytesSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store)
        internal
        pure
        returns (BytesSlot storage r)
    {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    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 overflow flag.
     */
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        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 division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

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

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

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return 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.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev 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^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + 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^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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^256 / 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^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            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^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // 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^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, 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;
        }
    }

    /**
     * @notice 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) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice 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 +
                (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 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 +
                (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @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 +
                (unsignedRoundsUp(rounding) && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 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 +
                (
                    unsignedRoundsUp(rounding) && 1 << (result << 3) < value
                        ? 1
                        : 0
                );
        }
    }

    /**
     * @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/Arrays.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element)
        internal
        view
        returns (uint256)
    {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos)
        internal
        pure
        returns (StorageSlot.AddressSlot storage)
    {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos)
        internal
        pure
        returns (StorageSlot.Bytes32Slot storage)
    {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos)
        internal
        pure
        returns (StorageSlot.Uint256Slot storage)
    {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos)
        internal
        pure
        returns (uint256 res)
    {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos)
        internal
        pure
        returns (address res)
    {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return 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 {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @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;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    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)
    {
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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 Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b)
        internal
        pure
        returns (bool)
    {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

pragma solidity ^0.8.23;

abstract contract Ownable {
    address private _owner;

    error OwnableUnauthorizedAccount(address account);

    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        if (owner() != msg.sender) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract ERC11 is Ownable {
    using Arrays for uint256[];
    using Arrays for address[];
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(uint256 => mapping(address => uint256)) private _nft_balances;
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    string private _name;
    string private _symbol;
    uint256 private _totalSupply;
    uint8 private constant _decimals = 18;
    uint256 public immutable _nft_count;

    mapping(address => bool) private _allowList;

    // Events ERC20

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    // Events ERC1155
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );

    event URI(string value, uint256 indexed id);

    event AllowListChange(address indexed target, bool approved);

    // Errors

    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );
    error ERC1155InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed,
        uint256 tokenId
    );

    error InvalidSender(address sender);
    error InvalidReceiver(address receiver);
    error InsufficientAllowance(
        address spender,
        uint256 allowance,
        uint256 needed
    );
    error MissingApprovalForAll(address operator, address owner);
    error InvalidOperator(address operator);
    error InvalidApprover(address approver);
    error InvalidSpender(address spender);
    error InvalidArrayLength(uint256 idsLength, uint256 valuesLength);

    constructor(
        string memory name_,
        string memory symbol_,
        uint256 supply_,
        uint256 nft_count_
    ) Ownable(msg.sender) {
        _name = name_;
        _symbol = symbol_;
        _nft_count = nft_count_;
        _allowList[msg.sender] = true;
        _mint(msg.sender, supply_ * 10**_decimals);
    }

    function isInAllowlist(address target) public view returns (bool) {
        return _allowList[target];
    }

    function setAllowList(address target, bool state) public onlyOwner {
        require(
            _allowList[target] != state,
            "Assigning the same state is not allowed"
        );
        _allowList[target] = state;
        uint256 balance = _balances[target];
        if (state) {
            uint256 tokens_to_burn = balance / 10**_decimals;
            if (tokens_to_burn > 0) {
                _nft_burn(target, 0, tokens_to_burn);
            }
        } else {
            uint256 tokens_to_mint = balance / 10**_decimals;
            if (tokens_to_mint > 0) {
                _nft_mint(target, 0, tokens_to_mint);
            }
        }
        emit AllowListChange(target, state);
    }

    // ERC 1155

    function balanceOf(address account, uint256 id)
        public
        view
        returns (uint256)
    {
        require(id < _nft_count, "invalid token id");
        return _nft_balances[id][account];
    }

    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory)
    {
        if (accounts.length != ids.length) {
            revert InvalidArrayLength(ids.length, accounts.length);
        }

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    function isApprovedForAll(address account, address operator)
        public
        view
        returns (bool)
    {
        return _operatorApprovals[account][operator];
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external {
        address sender = msg.sender;
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert MissingApprovalForAll(sender, from);
        }
        _safeTransferFrom(from, to, id, value, data);
    }

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external {
        address sender = msg.sender;
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert MissingApprovalForAll(sender, from);
        }
        _safeBatchTransferFrom(from, to, ids, values, data);
    }

    function setApprovalForAll(address operator, bool approved) external {
        if (operator == address(0)) {
            revert InvalidOperator(address(0));
        }
        address owner = msg.sender;
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    function _nft_update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual {
        if (ids.length != values.length) {
            revert InvalidArrayLength(ids.length, values.length);
        }

        address operator = msg.sender;

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 value = values.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = _nft_balances[id][from];
                if (fromBalance < value) {
                    revert ERC1155InsufficientBalance(
                        from,
                        fromBalance,
                        value,
                        id
                    );
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance
                    _nft_balances[id][from] = fromBalance - value;
                }
            }

            if (to != address(0)) {
                _nft_balances[id][to] += value;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 value = values.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, value);
        } else {
            emit TransferBatch(operator, from, to, ids, values);
        }
    }

    function _nft_burn(
        address from,
        uint256 id,
        uint256 value
    ) internal {
        if (from == address(0)) {
            revert IERC1155Errors.ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(
            id,
            value
        );
        _nft_update(from, address(0), ids, values);
    }

    function _nft_mint(
        address to,
        uint256 id,
        uint256 value
    ) internal {
        if (to == address(0)) {
            revert IERC1155Errors.ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(
            id,
            value
        );
        _nft_update(address(0), to, ids, values);
    }

    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) internal {
        if (to == address(0)) {
            revert InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(
            id,
            value
        );
        _update(from, to, value * 10**_decimals);
        if (!isInAllowlist(from)) {
            _nft_update(from, address(0), ids, values);
        }
        if (!isInAllowlist(to)) {
            _nft_mint(to, 0, value);
            ERC1155Utils.checkOnERC1155Received(
                msg.sender,
                address(0),
                to,
                id,
                value,
                data
            );
        }
    }

    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes calldata data
    ) internal {
        if (to == address(0)) {
            revert InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert InvalidSender(address(0));
        }
        uint256 value;
        for (uint256 i = 0; i < ids.length; i++) {
            value += values[i];
        }
        _update(from, to, value * 10**_decimals);
        if (!isInAllowlist(from)) {
            _nft_update(from, address(0), ids, values);
        }
        if (!isInAllowlist(to)) {
            _nft_mint(to, 0, value);
            ERC1155Utils.checkOnERC1155BatchReceived(
                msg.sender,
                address(0),
                to,
                ids,
                values,
                data
            );
        }
    }

    function _asSingletonArrays(uint256 element1, uint256 element2)
        private
        pure
        returns (uint256[] memory array1, uint256[] memory array2)
    {
        assembly ("memory-safe") {
            array1 := mload(0x40)
            mstore(array1, 1)
            mstore(add(array1, 0x20), element1)
            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)
            mstore(0x40, add(array2, 0x40))
        }
    }

    // ERC 20 methods

    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual returns (uint8) {
        return _decimals;
    }

    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 value) external returns (bool) {
        address owner = msg.sender;
        _transfer(owner, to, value);
        return true;
    }

    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 value) external returns (bool) {
        address owner = msg.sender;
        _approve(owner, spender, value);
        return true;
    }

    function increaseAllowance(address _spender, uint256 _addedValue)
        public
        returns (bool)
    {
        _approve(
            msg.sender,
            _spender,
            _allowances[msg.sender][_spender].add(_addedValue)
        );
        return true;
    }

    function decreaseAllowance(address _spender, uint256 _subtractedValue)
        public
        returns (bool)
    {
        uint256 currentAllowance = _allowances[msg.sender][_spender];
        require(
            currentAllowance >= _subtractedValue,
            "DECREASED_ALLOWANCE_BELOW_ZERO"
        );
        _approve(msg.sender, _spender, currentAllowance.sub(_subtractedValue));
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool) {
        address spender = msg.sender;
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        if (from == address(0)) {
            revert InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert InvalidReceiver(address(0));
        }

        uint256 balanceBeforeSender = _balances[from];
        uint256 balanceBeforeReceiver = _balances[to];

        _update(from, to, value);

        if (!isInAllowlist(from)) {
            uint256 tokens_to_burn = (balanceBeforeSender / 10**_decimals) -
                (_balances[from] / 10**_decimals);
            _nft_burn(from, 0, tokens_to_burn);
        }

        if (!isInAllowlist(to)) {
            uint256 tokens_to_mint = (_balances[to] / 10**_decimals) -
                (balanceBeforeReceiver / 10**_decimals);
            _nft_mint(to, 0, tokens_to_mint);
        }
    }

    function _update(
        address from,
        address to,
        uint256 value
    ) internal virtual {
        if (from == address(0)) {
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                _totalSupply -= value;
            }
        } else {
            unchecked {
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    function mint(address account, uint256 value) public {
        require(value <= 100, "Minting value exceeds the maximum of 100 tokens minted per tx.");
        if (account == address(0)) {
            revert InvalidReceiver(address(0));
        }
        uint256 balanceBeforeReceiver = _balances[account];

        _mint(account, value * 10**_decimals);

        if (!isInAllowlist(account)) {
            uint256 tokens_to_mint = (_balances[account] / 10**_decimals) -
                (balanceBeforeReceiver / 10**_decimals);
            _nft_mint(account, 0, tokens_to_mint);
        }
    }

    function burn(uint256 value) external {
        address owner = msg.sender;
        if (owner == address(0)) {
            revert InvalidSender(address(0));
        }
        if (!isInAllowlist(owner)) {
            revert InvalidSender(owner);
        }
        _burn(owner, value);
    }

    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) internal {
        _approve(owner, spender, value, true);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value,
        bool emitEvent
    ) internal virtual {
        if (owner == address(0)) {
            revert InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 value
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

pragma solidity ^0.8.23;

contract Groge is ERC11 {
    string public baseURI;

    constructor(
        string memory name_,
        string memory symbol_,
        string memory _baseURI
    ) ERC11(name_, symbol_, 0, 1) {
        baseURI = _baseURI;
    }

    function setURI(string memory newURI) public onlyOwner {
        baseURI = newURI;
    }

    function uri(uint256 _tokenId) public view returns (string memory) {
        return
            string(
                abi.encodePacked(
                    baseURI,
                    "/",
                    Strings.toString(_tokenId),
                    ".json"
                )
            );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"_baseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"MissingApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"AllowListChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"_nft_count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"isInAllowlist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setAllowList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000094772617920446f67650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000547524f4745000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004368747470733a2f2f697066732e696f2f697066732f516d5231537150323473665250746168776f4631436d444367487a477734715a74456a485969386b384839376f6a0000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Gray Doge
Arg [1] : symbol_ (string): GROGE
Arg [2] : _baseURI (string): https://ipfs.io/ipfs/QmR1SqP24sfRPtahwoF1CmDCgHzGw4qZtEjHYi8k8H97oj

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [4] : 4772617920446f67650000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 47524f4745000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [8] : 68747470733a2f2f697066732e696f2f697066732f516d523153715032347366
Arg [9] : 5250746168776f4631436d444367487a477734715a74456a485969386b384839
Arg [10] : 376f6a0000000000000000000000000000000000000000000000000000000000

61488:665:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48250:217;;;;;;:::i;:::-;;:::i;:::-;;;643:25:1;;;631:2;616:18;48250:217:0;;;;;;;;61736:90;;;;;;:::i;:::-;;:::i;:::-;;55148:91;;;:::i;:::-;;;;;;;:::i;56049:182::-;;;;;;:::i;:::-;;:::i;:::-;;;2445:14:1;;2438:22;2420:41;;2408:2;2393:18;56049:182:0;2280:187:1;61834:316:0;;;;;;:::i;:::-;;:::i;55449:99::-;55528:12;;55449:99;;56964:275;;;;;;:::i;:::-;;:::i;47379:110::-;;;;;;:::i;:::-;;:::i;49605:432::-;;;;;;:::i;:::-;;:::i;55350:91::-;;;45298:2;5365:36:1;;5353:2;5338:18;55350:91:0;5223:184:1;56239:284:0;;;;;;:::i;:::-;;:::i;59145:608::-;;;;;;:::i;:::-;;:::i;59761:298::-;;;;;;:::i;:::-;;:::i;48475:527::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;45307:35::-;;;;;61519:21;;;:::i;55556:112::-;;;;;;:::i;:::-;-1:-1:-1;;;;;55642:18:0;55615:7;55642:18;;;:9;:18;;;;;;;55556:112;44217:103;;;:::i;47497:726::-;;;;;;:::i;:::-;;:::i;43952:87::-;43998:7;44025:6;43952:87;;-1:-1:-1;;;;;44025:6:0;;;7374:51:1;;7362:2;7347:18;43952:87:0;7228:203:1;55247:95:0;;;:::i;50045:327::-;;;;;;:::i;:::-;;:::i;56531:425::-;;;;;;:::i;:::-;;:::i;55676:174::-;;;;;;:::i;:::-;;:::i;55858:183::-;;;;;;:::i;:::-;-1:-1:-1;;;;;56006:18:0;;;55974:7;56006:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;55858:183;49010;;;;;;:::i;:::-;;:::i;49201:396::-;;;;;;:::i;:::-;;:::i;44328:220::-;;;;;;:::i;:::-;;:::i;48250:217::-;48346:7;48384:10;48379:2;:15;48371:44;;;;-1:-1:-1;;;48371:44:0;;8701:2:1;48371:44:0;;;8683:21:1;8740:2;8720:18;;;8713:30;-1:-1:-1;;;8759:18:1;;;8752:46;8815:18;;48371:44:0;;;;;;;;;-1:-1:-1;48433:17:0;;;;:13;:17;;;;;;;;-1:-1:-1;;;;;48433:26:0;;;;;;;;;;48250:217;;;;;:::o;61736:90::-;43911:13;:11;:13::i;:::-;61802:7:::1;:16;61812:6:::0;61802:7;:16:::1;:::i;:::-;;61736:90:::0;:::o;55148:91::-;55193:13;55226:5;55219:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55148:91;:::o;56049:182::-;56116:4;56149:10;56170:31;56149:10;56186:7;56195:5;56170:8;:31::i;:::-;-1:-1:-1;56219:4:0;;56049:182;-1:-1:-1;;;56049:182:0:o;61834:316::-;61886:13;61996:7;62052:26;62069:8;62052:16;:26::i;:::-;61957:170;;;;;;;;;:::i;:::-;;;;;;;;;;;;;61912:230;;61834:316;;;:::o;56964:275::-;57079:4;57114:10;57135:37;57151:4;57114:10;57166:5;57135:15;:37::i;:::-;57183:26;57193:4;57199:2;57203:5;57183:9;:26::i;:::-;-1:-1:-1;57227:4:0;;56964:275;-1:-1:-1;;;;56964:275:0:o;47379:110::-;-1:-1:-1;;;;;47463:18:0;47439:4;47463:18;;;:10;:18;;;;;;;;;47379:110::o;49605:432::-;49823:10;-1:-1:-1;;;;;49848:14:0;;;;;;;:49;;;49867:30;49884:4;49890:6;49867:16;:30::i;:::-;49866:31;49848:49;49844:124;;;49921:35;;-1:-1:-1;;;49921:35:0;;-1:-1:-1;;;;;12926:32:1;;;49921:35:0;;;12908:51:1;12995:32;;12975:18;;;12968:60;12881:18;;49921:35:0;12734:300:1;49844:124:0;49978:51;50001:4;50007:2;50011:3;;49978:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49978:51:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50016:6:0;;-1:-1:-1;50016:6:0;;;;49978:51;;;50016:6;;49978:51;50016:6;49978:51;;;;;;;;;-1:-1:-1;50024:4:0;;-1:-1:-1;50024:4:0;;-1:-1:-1;49978:22:0;;-1:-1:-1;49978:51:0:i;:::-;49795:242;49605:432;;;;;;;;:::o;56239:284::-;56384:10;56339:4;56432:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;56432:33:0;;;;;;;;;;56339:4;;56361:132;;56409:8;;56432:50;;56470:11;56432:37;:50::i;:::-;56361:8;:132::i;:::-;-1:-1:-1;56511:4:0;56239:284;;;;:::o;59145:608::-;59226:3;59217:5;:12;;59209:87;;;;-1:-1:-1;;;59209:87:0;;13241:2:1;59209:87:0;;;13223:21:1;13280:2;13260:18;;;13253:30;13319:34;13299:18;;;13292:62;13390:32;13370:18;;;13363:60;13440:19;;59209:87:0;13039:426:1;59209:87:0;-1:-1:-1;;;;;59311:21:0;;59307:88;;59356:27;;-1:-1:-1;;;59356:27:0;;59380:1;59356:27;;;7374:51:1;7347:18;;59356:27:0;7228:203:1;59307:88:0;-1:-1:-1;;;;;59437:18:0;;59405:29;59437:18;;;:9;:18;;;;;;59468:37;59447:7;59491:13;45298:2;59491;:13;:::i;:::-;59483:21;;:5;:21;:::i;:::-;59468:5;:37::i;:::-;59523:22;59537:7;59523:13;:22::i;:::-;59518:228;;59562:22;59668:13;45298:2;59668;:13;:::i;:::-;59644:37;;:21;:37;:::i;:::-;59609:13;45298:2;59609;:13;:::i;:::-;-1:-1:-1;;;;;59588:18:0;;;;;;:9;:18;;;;;;:34;;;;:::i;:::-;59587:95;;;;:::i;:::-;59562:120;;59697:37;59707:7;59716:1;59719:14;59697:9;:37::i;:::-;59547:199;59518:228;59198:555;59145:608;;:::o;59761:298::-;59826:10;;59847:84;;59894:25;;-1:-1:-1;;;59894:25:0;;59916:1;59894:25;;;7374:51:1;7347:18;;59894:25:0;7228:203:1;59847:84:0;59946:20;59960:5;59946:13;:20::i;:::-;59941:81;;59990:20;;-1:-1:-1;;;59990:20:0;;-1:-1:-1;;;;;7392:32:1;;59990:20:0;;;7374:51:1;7347:18;;59990:20:0;7228:203:1;59941:81:0;60032:19;60038:5;60045;60032;:19::i;48475:527::-;48602:16;48640:29;;;48636:116;;48693:47;;-1:-1:-1;;;48693:47:0;;;;;15868:25:1;;;15909:18;;;15902:34;;;15841:18;;48693:47:0;15694:248:1;48636:116:0;48764:30;48811:8;-1:-1:-1;;;;;48797:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48797:30:0;;48764:63;;48845:9;48840:122;48860:19;;;48840:122;;;48920:30;48930:8;;48939:1;48930:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;48943:3;;48947:1;48943:6;;;;;;;:::i;:::-;;;;;;;48920:9;:30::i;:::-;48901:13;48915:1;48901:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;48881:3;;48840:122;;;-1:-1:-1;48981:13:0;48475:527;-1:-1:-1;;;;;48475:527:0:o;61519:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44217:103::-;43911:13;:11;:13::i;:::-;44282:30:::1;44309:1;44282:18;:30::i;:::-;44217:103::o:0;47497:726::-;43911:13;:11;:13::i;:::-;-1:-1:-1;;;;;47597:18:0;::::1;;::::0;;;:10:::1;:18;::::0;;;;;:27;::::1;;:18;::::0;;::::1;:27;;::::0;47575:116:::1;;;::::0;-1:-1:-1;;;47575:116:0;;16281:2:1;47575:116:0::1;::::0;::::1;16263:21:1::0;16320:2;16300:18;;;16293:30;16359:34;16339:18;;;16332:62;-1:-1:-1;;;16410:18:1;;;16403:37;16457:19;;47575:116:0::1;16079:403:1::0;47575:116:0::1;-1:-1:-1::0;;;;;47702:18:0;::::1;;::::0;;;:10:::1;:18;::::0;;;;;;;:26;;-1:-1:-1;;47702:26:0::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;;;-1:-1:-1;47757:17:0;;;;;;;;47785:385:::1;;47811:22;47846:13;45298:2;47846;:13;:::i;:::-;47836:23;::::0;:7;:23:::1;:::i;:::-;47811:48:::0;-1:-1:-1;47878:18:0;;47874:95:::1;;47917:36;47927:6;47935:1;47938:14;47917:9;:36::i;:::-;47796:184;47785:385;;;48001:22;48036:13;45298:2;48036;:13;:::i;:::-;48026:23;::::0;:7;:23:::1;:::i;:::-;48001:48:::0;-1:-1:-1;48068:18:0;;48064:95:::1;;48107:36;48117:6;48125:1;48128:14;48107:9;:36::i;:::-;47986:184;47785:385;48201:6;-1:-1:-1::0;;;;;48185:30:0::1;;48209:5;48185:30;;;;2445:14:1::0;2438:22;2420:41;;2408:2;2393:18;;2280:187;48185:30:0::1;;;;;;;;47564:659;47497:726:::0;;:::o;55247:95::-;55294:13;55327:7;55320:14;;;;;:::i;50045:327::-;-1:-1:-1;;;;;50129:22:0;;50125:89;;50175:27;;-1:-1:-1;;;50175:27:0;;50199:1;50175:27;;;7374:51:1;7347:18;;50175:27:0;7228:203:1;50125:89:0;50240:10;50224:13;50261:25;;;:18;:25;;;;;;;;-1:-1:-1;;;;;50261:35:0;;;;;;;;;;;;:46;;-1:-1:-1;;50261:46:0;;;;;;;;;;50323:41;;2420::1;;;50240:10:0;;50323:41;;2393:18:1;50323:41:0;;;;;;;;50114:258;50045:327;;:::o;56531:425::-;56697:10;56636:4;56685:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;56685:33:0;;;;;;;;;;56751:36;;;;56729:116;;;;-1:-1:-1;;;56729:116:0;;16689:2:1;56729:116:0;;;16671:21:1;16728:2;16708:18;;;16701:30;16767:32;16747:18;;;16740:60;16817:18;;56729:116:0;16487:354:1;56729:116:0;56856:70;56865:10;56877:8;56887:38;:16;56908;56887:20;:38::i;55676:174::-;55739:4;55772:10;55793:27;55772:10;55810:2;55814:5;55793:9;:27::i;49010:183::-;-1:-1:-1;;;;;49148:27:0;;;49119:4;49148:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;49010:183::o;49201:396::-;49390:10;-1:-1:-1;;;;;49415:14:0;;;;;;;:49;;;49434:30;49451:4;49457:6;49434:16;:30::i;:::-;49433:31;49415:49;49411:124;;;49488:35;;-1:-1:-1;;;49488:35:0;;-1:-1:-1;;;;;12926:32:1;;;49488:35:0;;;12908:51:1;12995:32;;12975:18;;;12968:60;12881:18;;49488:35:0;12734:300:1;49411:124:0;49545:44;49563:4;49569:2;49573;49577:5;49584:4;;49545:17;:44::i;:::-;49362:235;49201:396;;;;;;:::o;44328:220::-;43911:13;:11;:13::i;:::-;-1:-1:-1;;;;;44413:22:0;::::1;44409:93;;44459:31;::::0;-1:-1:-1;;;44459:31:0;;44487:1:::1;44459:31;::::0;::::1;7374:51:1::0;7347:18;;44459:31:0::1;7228:203:1::0;44409:93:0::1;44512:28;44531:8;44512:18;:28::i;:::-;44328:220:::0;:::o;44047:162::-;44118:10;44107:7;43998;44025:6;-1:-1:-1;;;;;44025:6:0;;43952:87;44107:7;-1:-1:-1;;;;;44107:21:0;;44103:99;;44152:38;;-1:-1:-1;;;44152:38:0;;44179:10;44152:38;;;7374:51:1;7347:18;;44152:38:0;7228:203:1;60281:164:0;60400:37;60409:5;60416:7;60425:5;60432:4;60400:8;:37::i;40791:716::-;40847:13;40898:14;40915:17;40926:5;40915:10;:17::i;:::-;40935:1;40915:21;40898:38;;40951:20;40985:6;-1:-1:-1;;;;;40974:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40974:18:0;-1:-1:-1;40951:41:0;-1:-1:-1;41116:28:0;;;41132:2;41116:28;41173:288;-1:-1:-1;;41205:5:0;-1:-1:-1;;;41342:2:0;41331:14;;41326:30;41205:5;41313:44;41403:2;41394:11;;;-1:-1:-1;41424:21:0;41173:288;41424:21;-1:-1:-1;41482:6:0;40791:716;-1:-1:-1;;;40791:716:0:o;60937:516::-;-1:-1:-1;;;;;56006:18:0;;;61071:24;56006:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;61138:37:0;;61134:312;;61215:5;61196:16;:24;61192:127;;;61248:55;;-1:-1:-1;;;61248:55:0;;-1:-1:-1;;;;;17066:32:1;;61248:55:0;;;17048:51:1;17115:18;;;17108:34;;;17158:18;;;17151:34;;;17021:18;;61248:55:0;16846:345:1;61192:127:0;61362:57;61371:5;61378:7;61406:5;61387:16;:24;61413:5;61362:8;:57::i;57247:902::-;-1:-1:-1;;;;;57365:18:0;;57361:83;;57407:25;;-1:-1:-1;;;57407:25:0;;57429:1;57407:25;;;7374:51:1;7347:18;;57407:25:0;7228:203:1;57361:83:0;-1:-1:-1;;;;;57458:16:0;;57454:83;;57498:27;;-1:-1:-1;;;57498:27:0;;57522:1;57498:27;;;7374:51:1;7347:18;;57498:27:0;7228:203:1;57454:83:0;-1:-1:-1;;;;;57579:15:0;;;57549:27;57579:15;;;:9;:15;;;;;;;57637:13;;;;;;;;57663:24;57589:4;57647:2;57681:5;57663:7;:24::i;:::-;57705:19;57719:4;57705:13;:19::i;:::-;57700:217;;57741:22;57842:13;45298:2;57842;:13;:::i;:::-;-1:-1:-1;;;;;57824:15:0;;;;;;:9;:15;;;;;;:31;;;;:::i;:::-;57789:13;45298:2;57789;:13;:::i;:::-;57767:35;;:19;:35;:::i;:::-;57766:90;;;;:::i;:::-;57741:115;;57871:34;57881:4;57887:1;57890:14;57871:9;:34::i;:::-;57726:191;57700:217;57934:17;57948:2;57934:13;:17::i;:::-;57929:213;;57968:22;58069:13;45298:2;58069;:13;:::i;:::-;58045:37;;:21;:37;:::i;:::-;58010:13;45298:2;58010;:13;:::i;:::-;-1:-1:-1;;;;;57994:13:0;;;;;;:9;:13;;;;;;:29;;;;:::i;:::-;57993:90;;;;:::i;:::-;57968:115;;58098:32;58108:2;58112:1;58115:14;58098:9;:32::i;:::-;57953:189;57929:213;57350:799;;57247:902;;;:::o;53643:960::-;-1:-1:-1;;;;;53845:16:0;;53841:83;;53885:27;;-1:-1:-1;;;53885:27:0;;53909:1;53885:27;;;7374:51:1;7347:18;;53885:27:0;7228:203:1;53841:83:0;-1:-1:-1;;;;;53938:18:0;;53934:83;;53980:25;;-1:-1:-1;;;53980:25:0;;54002:1;53980:25;;;7374:51:1;7347:18;;53980:25:0;7228:203:1;53934:83:0;54027:13;;54051:86;54075:3;:10;54071:1;:14;54051:86;;;54116:6;54123:1;54116:9;;;;;;;;:::i;:::-;;;;;;;54107:18;;;;;:::i;:::-;;-1:-1:-1;54087:3:0;;54051:86;;;-1:-1:-1;54147:40:0;54155:4;54161:2;54173:13;45298:2;54173;:13;:::i;:::-;54165:21;;:5;:21;:::i;:::-;54147:7;:40::i;:::-;54203:19;54217:4;54203:13;:19::i;:::-;54198:95;;54239:42;54251:4;54265:1;54269:3;54274:6;54239:11;:42::i;:::-;54308:17;54322:2;54308:13;:17::i;:::-;54303:293;;54342:23;54352:2;54356:1;54359:5;54342:9;:23::i;:::-;54380:204;54439:10;54476:1;54497:2;54518:3;54540:6;54565:4;;54380:204;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54380:40:0;;-1:-1:-1;;;54380:204:0:i;14727:141::-;14785:9;14811:5;14815:1;14811;:5;:::i;:::-;14807:9;;14839:1;14834;:6;;14827:14;;;;:::i;58929:208::-;-1:-1:-1;;;;;59000:21:0;;58996:88;;59045:27;;-1:-1:-1;;;59045:27:0;;59069:1;59045:27;;;7374:51:1;7347:18;;59045:27:0;7228:203:1;58996:88:0;59094:35;59110:1;59114:7;59123:5;59094:7;:35::i;52290:402::-;-1:-1:-1;;;;;52406:16:0;;52402:105;;52446:49;;-1:-1:-1;;;52446:49:0;;52492:1;52446:49;;;7374:51:1;7347:18;;52446:49:0;7228:203:1;52402:105:0;54846:4;54840:11;;54880:1;54865:17;;;54915:4;54903:17;;54896:35;;;54955:17;;;54986;;;54724:23;55024:17;;55017:35;;;55079:17;;;55066:31;;;54840:11;52644:40;-1:-1:-1;52668:2:0;54840:11;54955:17;52644:11;:40::i;60067:206::-;-1:-1:-1;;;;;60138:21:0;;60134:86;;60183:25;;-1:-1:-1;;;60183:25:0;;60205:1;60183:25;;;7374:51:1;7347:18;;60183:25:0;7228:203:1;60134:86:0;60230:35;60238:7;60255:1;60259:5;60230:7;:35::i;44556:191::-;44630:16;44649:6;;-1:-1:-1;;;;;44666:17:0;;;-1:-1:-1;;;;;;44666:17:0;;;;;;44699:40;;44649:6;;;;;;;44699:40;;44630:16;44699:40;44619:128;44556:191;:::o;51876:406::-;-1:-1:-1;;;;;51994:18:0;;51990:105;;52036:47;;-1:-1:-1;;;52036:47:0;;52080:1;52036:47;;;7374:51:1;7347:18;;52036:47:0;7228:203:1;51990:105:0;54846:4;54840:11;;54880:1;54865:17;;;54915:4;54903:17;;54896:35;;;54955:17;;;54986;;;54724:23;55024:17;;55017:35;;;55079:17;;;55066:31;;;54840:11;52232:42;52244:4;-1:-1:-1;54840:11:0;54955:17;52232:11;:42::i;14527:123::-;14585:7;14617:1;14612;:6;;14605:14;;;;:::i;:::-;14637:5;14641:1;14637;:5;:::i;:::-;14630:12;14527:123;-1:-1:-1;;;14527:123:0:o;52700:935::-;-1:-1:-1;;;;;52877:16:0;;52873:83;;52917:27;;-1:-1:-1;;;52917:27:0;;52941:1;52917:27;;;7374:51:1;7347:18;;52917:27:0;7228:203:1;52873:83:0;-1:-1:-1;;;;;52970:18:0;;52966:83;;53012:25;;-1:-1:-1;;;53012:25:0;;53034:1;53012:25;;;7374:51:1;7347:18;;53012:25:0;7228:203:1;52966:83:0;54846:4;54840:11;;54880:1;54865:17;;;54915:4;54903:17;;54896:35;;;54955:17;;;54986;;;54724:23;55024:17;;55017:35;;;55079:17;;;55066:31;;;54840:11;53186:40;53194:4;53200:2;53212:13;45298:2;53212;:13;:::i;:::-;53204:21;;:5;:21;:::i;53186:40::-;53242:19;53256:4;53242:13;:19::i;:::-;53237:95;;53278:42;53290:4;53304:1;53308:3;53313:6;53278:11;:42::i;:::-;53347:17;53361:2;53347:13;:17::i;:::-;53342:286;;53381:23;53391:2;53395:1;53398:5;53381:9;:23::i;:::-;53419:197;53473:10;53510:1;53531:2;53552;53573:5;53597:4;;53419:197;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53419:35:0;;-1:-1:-1;;;53419:197:0:i;:::-;52862:773;;52700:935;;;;;;:::o;60453:476::-;-1:-1:-1;;;;;60609:19:0;;60605:86;;60652:27;;-1:-1:-1;;;60652:27:0;;60676:1;60652:27;;;7374:51:1;7347:18;;60652:27:0;7228:203:1;60605:86:0;-1:-1:-1;;;;;60705:21:0;;60701:87;;60750:26;;-1:-1:-1;;;60750:26:0;;60773:1;60750:26;;;7374:51:1;7347:18;;60750:26:0;7228:203:1;60701:87:0;-1:-1:-1;;;;;60798:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;60844:78;;;;60895:7;-1:-1:-1;;;;;60879:31:0;60888:5;-1:-1:-1;;;;;60879:31:0;;60904:5;60879:31;;;;643:25:1;;631:2;616:18;;497:177;60879:31:0;;;;;;;;60453:476;;;;:::o;31100:922::-;31153:7;;-1:-1:-1;;;31231:15:0;;31227:102;;-1:-1:-1;;;31267:15:0;;;-1:-1:-1;31311:2:0;31301:12;31227:102;31356:6;31347:5;:15;31343:102;;31392:6;31383:15;;;-1:-1:-1;31427:2:0;31417:12;31343:102;31472:6;31463:5;:15;31459:102;;31508:6;31499:15;;;-1:-1:-1;31543:2:0;31533:12;31459:102;31588:5;31579;:14;31575:99;;31623:5;31614:14;;;-1:-1:-1;31657:1:0;31647:11;31575:99;31701:5;31692;:14;31688:99;;31736:5;31727:14;;;-1:-1:-1;31770:1:0;31760:11;31688:99;31814:5;31805;:14;31801:99;;31849:5;31840:14;;;-1:-1:-1;31883:1:0;31873:11;31801:99;31927:5;31918;:14;31914:66;;31963:1;31953:11;32008:6;31100:922;-1:-1:-1;;31100:922:0:o;58157:764::-;-1:-1:-1;;;;;58281:18:0;;58277:369;;58332:5;58316:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;58277:369:0;;-1:-1:-1;58277:369:0;;-1:-1:-1;;;;;58392:15:0;;58370:19;58392:15;;;:9;:15;;;;;;58426:19;;;58422:117;;;58473:50;;-1:-1:-1;;;58473:50:0;;-1:-1:-1;;;;;17066:32:1;;58473:50:0;;;17048:51:1;17115:18;;;17108:34;;;17158:18;;;17151:34;;;17021:18;;58473:50:0;16846:345:1;58422:117:0;-1:-1:-1;;;;;58582:15:0;;;;;;:9;:15;;;;;58600:19;;;;58582:37;;58277:369;-1:-1:-1;;;;;58662:16:0;;58658:213;;58724:12;:21;;;;;;;58658:213;;;-1:-1:-1;;;;;58822:13:0;;;;;;:9;:13;;;;;:22;;;;;;58658:213;58903:2;-1:-1:-1;;;;;58888:25:0;58897:4;-1:-1:-1;;;;;58888:25:0;;58907:5;58888:25;;;;643::1;;631:2;616:18;;497:177;50380:1488:0;50563:6;:13;50549:3;:10;:27;50545:112;;50619:10;;50631:13;;50600:45;;-1:-1:-1;;;50600:45:0;;;;;15868:25:1;;;;15909:18;;;15902:34;15841:18;;50600:45:0;15694:248:1;50545:112:0;50688:10;50669:16;50711:844;50735:3;:10;50731:1;:14;50711:844;;;38876:4;38867:14;;;38847:35;;;;;38841:42;38847:35;;;;;;38841:42;-1:-1:-1;;;;;50885:18:0;;;50881:560;;50924:19;50946:17;;;:13;:17;;;;;;;;-1:-1:-1;;;;;50946:23:0;;;;;;;;;;50992:19;;;50988:254;;;51043:179;;-1:-1:-1;;;51043:179:0;;-1:-1:-1;;;;;17707:32:1;;51043:179:0;;;17689:51:1;17756:18;;;17749:34;;;17799:18;;;17792:34;;;17842:18;;;17835:34;;;17661:19;;51043:179:0;17458:417:1;50988:254:0;51361:17;;;;:13;:17;;;;;;;;-1:-1:-1;;;;;51361:23:0;;;;;;;;;51387:19;;;;51361:45;;50881:560;-1:-1:-1;;;;;51461:16:0;;;51457:87;;51498:17;;;;:13;:17;;;;;;;;-1:-1:-1;;;;;51498:21:0;;;;;;;;;:30;;51523:5;;51498:17;:30;;51523:5;;51498:30;:::i;:::-;;;;-1:-1:-1;;51457:87:0;-1:-1:-1;;50747:3:0;;50711:844;;;;51571:3;:10;51585:1;51571:15;51567:294;;38876:4;38847:35;;38841:42;51603:10;;38876:4;38847:35;;38841:42;51603:38;;-1:-1:-1;51751:2:0;-1:-1:-1;;;;;51720:45:0;51745:4;-1:-1:-1;;;;;51720:45:0;51735:8;-1:-1:-1;;;;;51720:45:0;;51755:2;51759:5;51720:45;;;;;;15868:25:1;;;15924:2;15909:18;;15902:34;15856:2;15841:18;;15694:248;51720:45:0;;;;;;;;51588:189;;51567:294;;;51833:2;-1:-1:-1;;;;;51803:46:0;51827:4;-1:-1:-1;;;;;51803:46:0;51817:8;-1:-1:-1;;;;;51803:46:0;;51837:3;51842:6;51803:46;;;;;;;:::i;:::-;;;;;;;;50534:1334;50380:1488;;;;:::o;12323:1255::-;-1:-1:-1;;;;;12555:14:0;;;:18;12551:1020;;12611:202;;-1:-1:-1;;;12611:202:0;;-1:-1:-1;;;;;12611:43:0;;;;;:202;;12677:8;;12708:4;;12735:3;;12761:6;;12790:4;;12611:202;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12611:202:0;;;;;;;;-1:-1:-1;;12611:202:0;;;;;;;;;;;;:::i;:::-;;;12590:970;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13176:6;:13;13193:1;13176:18;13172:373;;13283:41;;-1:-1:-1;;;13283:41:0;;-1:-1:-1;;;;;7392:32:1;;13283:41:0;;;7374:51:1;7347:18;;13283:41:0;7228:203:1;13172:373:0;13495:6;13489:13;13480:6;13476:2;13472:15;13465:38;12590:970;-1:-1:-1;;;;;;12898:60:0;;-1:-1:-1;;;12898:60:0;12872:237;;13048:41;;-1:-1:-1;;;13048:41:0;;-1:-1:-1;;;;;7392:32:1;;13048:41:0;;;7374:51:1;7347:18;;13048:41:0;7228:203:1;10584:1178:0;-1:-1:-1;;;;;10791:14:0;;;:18;10787:968;;10847:195;;-1:-1:-1;;;10847:195:0;;-1:-1:-1;;;;;10847:38:0;;;;;:195;;10908:8;;10939:4;;10966:2;;10991:5;;11019:4;;10847:195;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10847:195:0;;;;;;;;-1:-1:-1;;10847:195:0;;;;;;;;;;;;:::i;:::-;;;10826:918;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;11105:55:0;;-1:-1:-1;;;11105:55:0;11101:192;;11232:41;;-1:-1:-1;;;11232:41:0;;-1:-1:-1;;;;;7392:32:1;;11232:41:0;;;7374:51:1;7347:18;;11232:41:0;7228:203:1;14:173;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:300::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;458:2;443:18;;;;430:32;;-1:-1:-1;;;192:300:1:o;679:127::-;740:10;735:3;731:20;728:1;721:31;771:4;768:1;761:15;795:4;792:1;785:15;811:945;880:6;933:2;921:9;912:7;908:23;904:32;901:52;;;949:1;946;939:12;901:52;989:9;976:23;-1:-1:-1;;;;;1014:6:1;1011:30;1008:50;;;1054:1;1051;1044:12;1008:50;1077:22;;1130:4;1122:13;;1118:27;-1:-1:-1;1108:55:1;;1159:1;1156;1149:12;1108:55;1199:2;1186:16;-1:-1:-1;;;;;1217:6:1;1214:30;1211:56;;;1247:18;;:::i;:::-;1296:2;1290:9;1388:2;1350:17;;-1:-1:-1;;1346:31:1;;;1379:2;1342:40;1338:54;1326:67;;-1:-1:-1;;;;;1408:34:1;;1444:22;;;1405:62;1402:88;;;1470:18;;:::i;:::-;1506:2;1499:22;1530;;;1571:15;;;1588:2;1567:24;1564:37;-1:-1:-1;1561:57:1;;;1614:1;1611;1604:12;1561:57;1670:6;1665:2;1661;1657:11;1652:2;1644:6;1640:15;1627:50;1723:1;1697:19;;;1718:2;1693:28;1686:39;;;;1701:6;811:945;-1:-1:-1;;;;811:945:1:o;1761:289::-;1803:3;1841:5;1835:12;1868:6;1863:3;1856:19;1924:6;1917:4;1910:5;1906:16;1899:4;1894:3;1890:14;1884:47;1976:1;1969:4;1960:6;1955:3;1951:16;1947:27;1940:38;2039:4;2032:2;2028:7;2023:2;2015:6;2011:15;2007:29;2002:3;1998:39;1994:50;1987:57;;;1761:289;;;;:::o;2055:220::-;2204:2;2193:9;2186:21;2167:4;2224:45;2265:2;2254:9;2250:18;2242:6;2224:45;:::i;2472:226::-;2531:6;2584:2;2572:9;2563:7;2559:23;2555:32;2552:52;;;2600:1;2597;2590:12;2552:52;-1:-1:-1;2645:23:1;;2472:226;-1:-1:-1;2472:226:1:o;2703:374::-;2780:6;2788;2796;2849:2;2837:9;2828:7;2824:23;2820:32;2817:52;;;2865:1;2862;2855:12;2817:52;2888:29;2907:9;2888:29;:::i;:::-;2878:39;;2936:38;2970:2;2959:9;2955:18;2936:38;:::i;:::-;2703:374;;2926:48;;-1:-1:-1;;;3043:2:1;3028:18;;;;3015:32;;2703:374::o;3082:186::-;3141:6;3194:2;3182:9;3173:7;3169:23;3165:32;3162:52;;;3210:1;3207;3200:12;3162:52;3233:29;3252:9;3233:29;:::i;3273:367::-;3336:8;3346:6;3400:3;3393:4;3385:6;3381:17;3377:27;3367:55;;3418:1;3415;3408:12;3367:55;-1:-1:-1;3441:20:1;;-1:-1:-1;;;;;3473:30:1;;3470:50;;;3516:1;3513;3506:12;3470:50;3553:4;3545:6;3541:17;3529:29;;3613:3;3606:4;3596:6;3593:1;3589:14;3581:6;3577:27;3573:38;3570:47;3567:67;;;3630:1;3627;3620:12;3567:67;3273:367;;;;;:::o;3645:347::-;3696:8;3706:6;3760:3;3753:4;3745:6;3741:17;3737:27;3727:55;;3778:1;3775;3768:12;3727:55;-1:-1:-1;3801:20:1;;-1:-1:-1;;;;;3833:30:1;;3830:50;;;3876:1;3873;3866:12;3830:50;3913:4;3905:6;3901:17;3889:29;;3965:3;3958:4;3949:6;3941;3937:19;3933:30;3930:39;3927:59;;;3982:1;3979;3972:12;3997:1221;4157:6;4165;4173;4181;4189;4197;4205;4213;4266:3;4254:9;4245:7;4241:23;4237:33;4234:53;;;4283:1;4280;4273:12;4234:53;4306:29;4325:9;4306:29;:::i;:::-;4296:39;;4354:38;4388:2;4377:9;4373:18;4354:38;:::i;:::-;4344:48;;4443:2;4432:9;4428:18;4415:32;-1:-1:-1;;;;;4462:6:1;4459:30;4456:50;;;4502:1;4499;4492:12;4456:50;4541:70;4603:7;4594:6;4583:9;4579:22;4541:70;:::i;:::-;4630:8;;-1:-1:-1;4515:96:1;-1:-1:-1;;4718:2:1;4703:18;;4690:32;-1:-1:-1;;;;;4734:32:1;;4731:52;;;4779:1;4776;4769:12;4731:52;4818:72;4882:7;4871:8;4860:9;4856:24;4818:72;:::i;:::-;4909:8;;-1:-1:-1;4792:98:1;-1:-1:-1;;4997:3:1;4982:19;;4969:33;-1:-1:-1;;;;;5014:32:1;;5011:52;;;5059:1;5056;5049:12;5011:52;5098:60;5150:7;5139:8;5128:9;5124:24;5098:60;:::i;:::-;3997:1221;;;;-1:-1:-1;3997:1221:1;;-1:-1:-1;3997:1221:1;;;;;;5177:8;-1:-1:-1;;;3997:1221:1:o;5412:768::-;5534:6;5542;5550;5558;5611:2;5599:9;5590:7;5586:23;5582:32;5579:52;;;5627:1;5624;5617:12;5579:52;5667:9;5654:23;-1:-1:-1;;;;;5692:6:1;5689:30;5686:50;;;5732:1;5729;5722:12;5686:50;5771:70;5833:7;5824:6;5813:9;5809:22;5771:70;:::i;:::-;5860:8;;-1:-1:-1;5745:96:1;-1:-1:-1;;5948:2:1;5933:18;;5920:32;-1:-1:-1;;;;;5964:32:1;;5961:52;;;6009:1;6006;5999:12;5961:52;6048:72;6112:7;6101:8;6090:9;6086:24;6048:72;:::i;:::-;5412:768;;;;-1:-1:-1;6139:8:1;-1:-1:-1;;;;5412:768:1:o;6185:420::-;6238:3;6276:5;6270:12;6303:6;6298:3;6291:19;6335:4;6330:3;6326:14;6319:21;;6374:4;6367:5;6363:16;6397:1;6407:173;6421:6;6418:1;6415:13;6407:173;;;6482:13;;6470:26;;6525:4;6516:14;;;;6553:17;;;;6443:1;6436:9;6407:173;;;-1:-1:-1;6596:3:1;;6185:420;-1:-1:-1;;;;6185:420:1:o;6610:261::-;6789:2;6778:9;6771:21;6752:4;6809:56;6861:2;6850:9;6846:18;6838:6;6809:56;:::i;6876:347::-;6941:6;6949;7002:2;6990:9;6981:7;6977:23;6973:32;6970:52;;;7018:1;7015;7008:12;6970:52;7041:29;7060:9;7041:29;:::i;:::-;7031:39;;7120:2;7109:9;7105:18;7092:32;7167:5;7160:13;7153:21;7146:5;7143:32;7133:60;;7189:1;7186;7179:12;7133:60;7212:5;7202:15;;;6876:347;;;;;:::o;7436:260::-;7504:6;7512;7565:2;7553:9;7544:7;7540:23;7536:32;7533:52;;;7581:1;7578;7571:12;7533:52;7604:29;7623:9;7604:29;:::i;:::-;7594:39;;7652:38;7686:2;7675:9;7671:18;7652:38;:::i;:::-;7642:48;;7436:260;;;;;:::o;7701:793::-;7807:6;7815;7823;7831;7839;7847;7900:3;7888:9;7879:7;7875:23;7871:33;7868:53;;;7917:1;7914;7907:12;7868:53;7940:29;7959:9;7940:29;:::i;:::-;7930:39;;7988:38;8022:2;8011:9;8007:18;7988:38;:::i;:::-;7978:48;-1:-1:-1;8095:2:1;8080:18;;8067:32;;-1:-1:-1;8196:2:1;8181:18;;8168:32;;-1:-1:-1;8277:3:1;8262:19;;8249:33;-1:-1:-1;;;;;8294:30:1;;8291:50;;;8337:1;8334;8327:12;8291:50;8376:58;8426:7;8417:6;8406:9;8402:22;8376:58;:::i;:::-;7701:793;;;;-1:-1:-1;7701:793:1;;-1:-1:-1;7701:793:1;;8453:8;;7701:793;-1:-1:-1;;;7701:793:1:o;8844:380::-;8923:1;8919:12;;;;8966;;;8987:61;;9041:4;9033:6;9029:17;9019:27;;8987:61;9094:2;9086:6;9083:14;9063:18;9060:38;9057:161;;9140:10;9135:3;9131:20;9128:1;9121:31;9175:4;9172:1;9165:15;9203:4;9200:1;9193:15;9057:161;;8844:380;;;:::o;9355:518::-;9457:2;9452:3;9449:11;9446:421;;;9493:5;9490:1;9483:16;9537:4;9534:1;9524:18;9607:2;9595:10;9591:19;9588:1;9584:27;9578:4;9574:38;9643:4;9631:10;9628:20;9625:47;;;-1:-1:-1;9666:4:1;9625:47;9721:2;9716:3;9712:12;9709:1;9705:20;9699:4;9695:31;9685:41;;9776:81;9794:2;9787:5;9784:13;9776:81;;;9853:1;9839:16;;9820:1;9809:13;9776:81;;10049:1299;10175:3;10169:10;-1:-1:-1;;;;;10194:6:1;10191:30;10188:56;;;10224:18;;:::i;:::-;10253:97;10343:6;10303:38;10335:4;10329:11;10303:38;:::i;:::-;10297:4;10253:97;:::i;:::-;10399:4;10430:2;10419:14;;10447:1;10442:649;;;;11135:1;11152:6;11149:89;;;-1:-1:-1;11204:19:1;;;11198:26;11149:89;-1:-1:-1;;10006:1:1;10002:11;;;9998:24;9994:29;9984:40;10030:1;10026:11;;;9981:57;11251:81;;10412:930;;10442:649;9302:1;9295:14;;;9339:4;9326:18;;-1:-1:-1;;10478:20:1;;;10596:222;10610:7;10607:1;10604:14;10596:222;;;10692:19;;;10686:26;10671:42;;10799:4;10784:20;;;;10752:1;10740:14;;;;10626:12;10596:222;;;10600:3;10846:6;10837:7;10834:19;10831:201;;;10907:19;;;10901:26;-1:-1:-1;;10990:1:1;10986:14;;;11002:3;10982:24;10978:37;10974:42;10959:58;10944:74;;10831:201;-1:-1:-1;;;;11078:1:1;11062:14;;;11058:22;11045:36;;-1:-1:-1;10049:1299:1:o;11471:1258::-;11849:3;11878:1;11911:6;11905:13;11941:36;11967:9;11941:36;:::i;:::-;12008:1;11993:17;;12019:133;;;;12166:1;12161:332;;;;11986:507;;12019:133;-1:-1:-1;;12052:24:1;;12040:37;;12125:14;;12118:22;12106:35;;12097:45;;;-1:-1:-1;12019:133:1;;12161:332;12192:6;12189:1;12182:17;12240:4;12237:1;12227:18;12267:1;12281:166;12295:6;12292:1;12289:13;12281:166;;;12375:14;;12362:11;;;12355:35;12431:1;12418:15;;;;12317:4;12310:12;12281:166;;;12285:3;;12476:6;12471:3;12467:16;12460:23;;11986:507;;;;-1:-1:-1;;;12509:3:1;12502:16;12549:6;12543:13;12603:8;12596:4;12588:6;12584:17;12580:1;12575:3;12571:11;12565:47;-1:-1:-1;;;12635:18:1;;12655:1;12631:26;;11413:20;;;11449:11;;12695:28;12688:35;11471:1258;-1:-1:-1;;;;;11471:1258:1:o;13470:127::-;13531:10;13526:3;13522:20;13519:1;13512:31;13562:4;13559:1;13552:15;13586:4;13583:1;13576:15;13602:375;13690:1;13708:5;13722:249;13743:1;13733:8;13730:15;13722:249;;;13793:4;13788:3;13784:14;13778:4;13775:24;13772:50;;;13802:18;;:::i;:::-;13852:1;13842:8;13838:16;13835:49;;;13866:16;;;;13835:49;13949:1;13945:16;;;;;13905:15;;13722:249;;;13602:375;;;;;;:::o;13982:902::-;14031:5;14061:8;14051:80;;-1:-1:-1;14102:1:1;14116:5;;14051:80;14150:4;14140:76;;-1:-1:-1;14187:1:1;14201:5;;14140:76;14232:4;14250:1;14245:59;;;;14318:1;14313:174;;;;14225:262;;14245:59;14275:1;14266:10;;14289:5;;;14313:174;14350:3;14340:8;14337:17;14334:43;;;14357:18;;:::i;:::-;-1:-1:-1;;14413:1:1;14399:16;;14472:5;;14225:262;;14571:2;14561:8;14558:16;14552:3;14546:4;14543:13;14539:36;14533:2;14523:8;14520:16;14515:2;14509:4;14506:12;14502:35;14499:77;14496:203;;;-1:-1:-1;14608:19:1;;;14684:5;;14496:203;14731:42;-1:-1:-1;;14756:8:1;14750:4;14731:42;:::i;:::-;14809:6;14805:1;14801:6;14797:19;14788:7;14785:32;14782:58;;;14820:18;;:::i;:::-;14858:20;;13982:902;-1:-1:-1;;;13982:902:1:o;14889:140::-;14947:5;14976:47;15017:4;15007:8;15003:19;14997:4;14976:47;:::i;15034:168::-;15107:9;;;15138;;15155:15;;;15149:22;;15135:37;15125:71;;15176:18;;:::i;15339:217::-;15379:1;15405;15395:132;;15449:10;15444:3;15440:20;15437:1;15430:31;15484:4;15481:1;15474:15;15512:4;15509:1;15502:15;15395:132;-1:-1:-1;15541:9:1;;15339:217::o;15561:128::-;15628:9;;;15649:11;;;15646:37;;;15663:18;;:::i;15947:127::-;16008:10;16003:3;15999:20;15996:1;15989:31;16039:4;16036:1;16029:15;16063:4;16060:1;16053:15;17196:125;17261:9;;;17282:10;;;17279:36;;;17295:18;;:::i;17326:127::-;17387:10;17382:3;17378:20;17375:1;17368:31;17418:4;17415:1;17408:15;17442:4;17439:1;17432:15;17880:465;18137:2;18126:9;18119:21;18100:4;18163:56;18215:2;18204:9;18200:18;18192:6;18163:56;:::i;:::-;18267:9;18259:6;18255:22;18250:2;18239:9;18235:18;18228:50;18295:44;18332:6;18324;18295:44;:::i;18350:823::-;-1:-1:-1;;;;;18709:32:1;;;18691:51;;18778:32;;18773:2;18758:18;;18751:60;18729:3;18842:2;18827:18;;18820:31;;;-1:-1:-1;;18874:57:1;;18911:19;;18903:6;18874:57;:::i;:::-;18979:9;18971:6;18967:22;18962:2;18951:9;18947:18;18940:50;19013:44;19050:6;19042;19013:44;:::i;:::-;18999:58;;19106:9;19098:6;19094:22;19088:3;19077:9;19073:19;19066:51;19134:33;19160:6;19152;19134:33;:::i;:::-;19126:41;18350:823;-1:-1:-1;;;;;;;;18350:823:1:o;19178:290::-;19247:6;19300:2;19288:9;19279:7;19275:23;19271:32;19268:52;;;19316:1;19313;19306:12;19268:52;19342:16;;-1:-1:-1;;;;;;19387:32:1;;19377:43;;19367:71;;19434:1;19431;19424:12;19473:557;-1:-1:-1;;;;;19732:32:1;;;19714:51;;19801:32;;19796:2;19781:18;;19774:60;19865:2;19850:18;;19843:34;;;19908:2;19893:18;;19886:34;;;19752:3;19951;19936:19;;19929:32;;;-1:-1:-1;;19978:46:1;;20004:19;;19996:6;19978:46;:::i;:::-;19970:54;19473:557;-1:-1:-1;;;;;;;19473:557:1:o

ipfs://49a11a5930801be825a47de988abe06e33746a41c3ef3a654bf4f897d2cf4af2