Contract

/**
 *Submitted for verification at Etherscan.io on 2023-09-21
*/

// File: solady/tokens/ERC1155.sol


pragma solidity ^0.8.4;

/// @notice Modern and gas efficient ERC1155 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC1155.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC1155/ERC1155.sol)
abstract contract ERC1155 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The lengths of the input arrays are not the same.
    error ArrayLengthsMismatch();

    /// @dev Cannot mint or transfer to the zero address.
    error TransferToZeroAddress();

    /// @dev The recipient's balance has overflowed.
    error AccountBalanceOverflow();

    /// @dev Insufficient balance.
    error InsufficientBalance();

    /// @dev Only the token owner or an approved account can manage the tokens.
    error NotOwnerNorApproved();

    /// @dev Cannot safely transfer to a contract that does not implement
    /// the ERC1155Receiver interface.
    error TransferToNonERC1155ReceiverImplementer();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when `amount` of token `id` is transferred
    /// from `from` to `to` by `operator`.
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 amount
    );

    /// @dev Emitted when `amounts` of token `ids` are transferred
    /// from `from` to `to` by `operator`.
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] amounts
    );

    /// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens.
    event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved);

    /// @dev Emitted when the Uniform Resource Identifier (URI) for token `id`
    /// is updated to `value`. This event is not used in the base contract.
    /// You may need to emit this event depending on your URI logic.
    ///
    /// See: https://eips.ethereum.org/EIPS/eip-1155#metadata
    event URI(string value, uint256 indexed id);

    /// @dev `keccak256(bytes("TransferSingle(address,address,address,uint256,uint256)"))`.
    uint256 private constant _TRANSFER_SINGLE_EVENT_SIGNATURE =
        0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62;

    /// @dev `keccak256(bytes("TransferBatch(address,address,address,uint256[],uint256[])"))`.
    uint256 private constant _TRANSFER_BATCH_EVENT_SIGNATURE =
        0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb;

    /// @dev `keccak256(bytes("ApprovalForAll(address,address,bool)"))`.
    uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =
        0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The `ownerSlotSeed` of a given owner is given by.
    /// ```
    ///     let ownerSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner))
    /// ```
    ///
    /// The balance slot of `owner` is given by.
    /// ```
    ///     mstore(0x20, ownerSlotSeed)
    ///     mstore(0x00, id)
    ///     let balanceSlot := keccak256(0x00, 0x40)
    /// ```
    ///
    /// The operator approval slot of `owner` is given by.
    /// ```
    ///     mstore(0x20, ownerSlotSeed)
    ///     mstore(0x00, operator)
    ///     let operatorApprovalSlot := keccak256(0x0c, 0x34)
    /// ```
    uint256 private constant _ERC1155_MASTER_SLOT_SEED = 0x9a31110384e0b0c9;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC1155 METADATA                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the URI for token `id`.
    ///
    /// Can either return the same templated URI for all token IDs,
    /// or substitute the `id` on the contract side.
    ///
    /// See: https://eips.ethereum.org/EIPS/eip-1155#metadata
    function uri(uint256 id) public view virtual returns (string memory);

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          ERC1155                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the amount of `id` owned by `owner`.
    function balanceOf(address owner, uint256 id) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner)))
            mstore(0x00, id)
            result := sload(keccak256(0x00, 0x40))
        }
    }

    /// @dev Returns whether `operator` is approved to manage the tokens of `owner`.
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner)))
            mstore(0x00, operator)
            result := sload(keccak256(0x0c, 0x34))
        }
    }

    /// @dev Sets whether `operator` is approved to manage the tokens of the caller.
    ///
    /// Emits a {ApprovalForAll} event.
    function setApprovalForAll(address operator, bool isApproved) public virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            operator := shr(96, shl(96, operator))
            // Convert to 0 or 1.
            isApproved := iszero(iszero(isApproved))
            // Update the `isApproved` for (`msg.sender`, `operator`).
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, caller())))
            mstore(0x00, operator)
            sstore(keccak256(0x0c, 0x34), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator)
        }
    }

    /// @dev Transfers `amount` of `id` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - If the caller is not `from`,
    ///   it must be approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Reveived}, which is called upon a batch transfer.
    ///
    /// Emits a {Transfer} event.
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) public virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            // If the caller is not `from`, do the authorization check.
            if iszero(eq(caller(), from)) {
                mstore(0x00, caller())
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, toSlotSeed)
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            {
                mstore(0x20, amount)
                log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), from, to)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // Do the {onERC1155Received} check if `to` is a smart contract.
            if extcodesize(to) {
                // Prepare the calldata.
                let m := mload(0x40)
                let onERC1155ReceivedSelector := 0xf23a6e61
                mstore(m, onERC1155ReceivedSelector)
                mstore(add(m, 0x20), caller())
                mstore(add(m, 0x40), from)
                mstore(add(m, 0x60), id)
                mstore(add(m, 0x80), amount)
                mstore(add(m, 0xa0), 0xa0)
                calldatacopy(add(m, 0xc0), sub(data.offset, 0x20), add(0x20, data.length))
                // Revert if the call reverts.
                if iszero(call(gas(), to, 0, add(m, 0x1c), add(0xc4, data.length), m, 0x20)) {
                    if returndatasize() {
                        // Bubble up the revert if the delegatecall reverts.
                        returndatacopy(0x00, 0x00, returndatasize())
                        revert(0x00, returndatasize())
                    }
                    mstore(m, 0)
                }
                // Load the returndata and compare it.
                if iszero(eq(mload(m), shl(224, onERC1155ReceivedSelector))) {
                    mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Transfers `amounts` of `ids` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - `ids` and `amounts` must have the same length.
    /// - If the caller is not `from`,
    ///   it must be approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReveived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) public virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(ids.length, amounts.length)) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // If the caller is not `from`, do the authorization check.
            if iszero(eq(caller(), from)) {
                mstore(0x00, caller())
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                let end := shl(5, ids.length)
                for { let i := 0 } iszero(eq(i, end)) { i := add(i, 0x20) } {
                    let amount := calldataload(add(amounts.offset, i))
                    // Subtract and store the updated balance of `from`.
                    {
                        mstore(0x20, fromSlotSeed)
                        mstore(0x00, calldataload(add(ids.offset, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x20, toSlotSeed)
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, ids.length))
                let o := add(m, 0x40)
                calldatacopy(o, sub(ids.offset, 0x20), n)
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, n))
                o := add(o, n)
                n := add(0x20, shl(5, amounts.length))
                calldatacopy(o, sub(amounts.offset, 0x20), n)
                n := sub(add(o, n), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), from, to)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransferCalldata(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // Do the {onERC1155BatchReceived} check if `to` is a smart contract.
            if extcodesize(to) {
                let m := mload(0x40)
                // Prepare the calldata.
                let onERC1155BatchReceivedSelector := 0xbc197c81
                mstore(m, onERC1155BatchReceivedSelector)
                mstore(add(m, 0x20), caller())
                mstore(add(m, 0x40), from)
                // Copy the `ids`.
                mstore(add(m, 0x60), 0xa0)
                let n := add(0x20, shl(5, ids.length))
                let o := add(m, 0xc0)
                calldatacopy(o, sub(ids.offset, 0x20), n)
                // Copy the `amounts`.
                let s := add(0xa0, n)
                mstore(add(m, 0x80), s)
                o := add(o, n)
                n := add(0x20, shl(5, amounts.length))
                calldatacopy(o, sub(amounts.offset, 0x20), n)
                // Copy the `data`.
                mstore(add(m, 0xa0), add(s, n))
                o := add(o, n)
                n := add(0x20, data.length)
                calldatacopy(o, sub(data.offset, 0x20), n)
                n := sub(add(o, n), add(m, 0x1c))
                // Revert if the call reverts.
                if iszero(call(gas(), to, 0, add(m, 0x1c), n, m, 0x20)) {
                    if returndatasize() {
                        // Bubble up the revert if the delegatecall reverts.
                        returndatacopy(0x00, 0x00, returndatasize())
                        revert(0x00, returndatasize())
                    }
                    mstore(m, 0)
                }
                // Load the returndata and compare it.
                if iszero(eq(mload(m), shl(224, onERC1155BatchReceivedSelector))) {
                    mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Returns the amounts of `ids` for `owners.
    ///
    /// Requirements:
    /// - `owners` and `ids` must have the same length.
    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        public
        view
        virtual
        returns (uint256[] memory balances)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(ids.length, owners.length)) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            balances := mload(0x40)
            mstore(balances, ids.length)
            let o := add(balances, 0x20)
            let end := shl(5, ids.length)
            mstore(0x40, add(end, o))
            // Loop through all the `ids` and load the balances.
            for { let i := 0 } iszero(eq(i, end)) { i := add(i, 0x20) } {
                let owner := calldataload(add(owners.offset, i))
                mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner)))
                mstore(0x00, calldataload(add(ids.offset, i)))
                mstore(add(o, i), sload(keccak256(0x00, 0x40)))
            }
        }
    }

    /// @dev Returns true if this contract implements the interface defined by `interfaceId`.
    /// See: https://eips.ethereum.org/EIPS/eip-165
    /// This function call must use less than 30000 gas.
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := shr(224, interfaceId)
            // ERC165: 0x01ffc9a7, ERC1155: 0xd9b67a26, ERC1155MetadataURI: 0x0e89341c.
            result := or(or(eq(s, 0x01ffc9a7), eq(s, 0xd9b67a26)), eq(s, 0x0e89341c))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Mints `amount` of `id` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Reveived}, which is called upon a batch transfer.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(address(0), to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            // Clear the upper 96 bits.
            to := shr(96, toSlotSeed)
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, toSlotSeed)
                mstore(0x00, id)
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            {
                mstore(0x00, id)
                mstore(0x20, amount)
                log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), 0, to)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(address(0), to, _single(id), _single(amount), data);
        }
        if (_hasCode(to)) _checkOnERC1155Received(address(0), to, id, amount, data);
    }

    /// @dev Mints `amounts` of `ids` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `ids` and `amounts` must have the same length.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReveived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function _batchMint(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(address(0), to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            // Clear the upper 96 bits.
            to := shr(96, toSlotSeed)
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Loop through all the `ids` and update the balances.
            {
                let end := shl(5, mload(ids))
                for { let i := 0 } iszero(eq(i, end)) {} {
                    i := add(i, 0x20)
                    let amount := mload(add(amounts, i))
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x20, toSlotSeed)
                        mstore(0x00, mload(add(ids, i)))
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), 0, to)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(address(0), to, ids, amounts, data);
        }
        if (_hasCode(to)) _checkOnERC1155BatchReceived(address(0), to, ids, amounts, data);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Equivalent to `_burn(address(0), from, id, amount)`.
    function _burn(address from, uint256 id, uint256 amount) internal virtual {
        _burn(address(0), from, id, amount);
    }

    /// @dev Destroys `amount` of `id` from `from`.
    ///
    /// Requirements:
    /// - `from` must have at least `amount` of `id`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function _burn(address by, address from, uint256 id, uint256 amount) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, address(0), _single(id), _single(amount), "");
        }
        /// @solidity memory-safe-assembly
        assembly {
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            by := shr(96, shl(96, by))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            if iszero(or(iszero(by), eq(by, from))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Decrease and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Emit a {TransferSingle} event.
            {
                mstore(0x00, id)
                mstore(0x20, amount)
                log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), from, 0)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, address(0), _single(id), _single(amount), "");
        }
    }

    /// @dev Equivalent to `_batchBurn(address(0), from, ids, amounts)`.
    function _batchBurn(address from, uint256[] memory ids, uint256[] memory amounts)
        internal
        virtual
    {
        _batchBurn(address(0), from, ids, amounts);
    }

    /// @dev Destroys `amounts` of `ids` from `from`.
    ///
    /// Requirements:
    /// - `ids` and `amounts` must have the same length.
    /// - `from` must have at least `amounts` of `ids`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    ///
    /// Emits a {TransferBatch} event.
    function _batchBurn(address by, address from, uint256[] memory ids, uint256[] memory amounts)
        internal
        virtual
    {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, address(0), ids, amounts, "");
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            by := shr(96, shl(96, by))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            if iszero(or(iszero(by), eq(by, from))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                let end := shl(5, mload(ids))
                for { let i := 0 } iszero(eq(i, end)) {} {
                    i := add(i, 0x20)
                    let amount := mload(add(amounts, i))
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x00, mload(add(ids, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), from, 0)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, address(0), ids, amounts, "");
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL APPROVAL FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Approve or remove the `operator` as an operator for `by`,
    /// without authorization checks.
    ///
    /// Emits a {ApprovalForAll} event.
    function _setApprovalForAll(address by, address operator, bool isApproved) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            operator := shr(96, shl(96, operator))
            // Convert to 0 or 1.
            isApproved := iszero(iszero(isApproved))
            // Update the `isApproved` for (`by`, `operator`).
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, by)))
            mstore(0x00, operator)
            sstore(keccak256(0x0c, 0x34), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Equivalent to `_safeTransfer(address(0), from, to, id, amount, data)`.
    function _safeTransfer(address from, address to, uint256 id, uint256 amount, bytes memory data)
        internal
        virtual
    {
        _safeTransfer(address(0), from, to, id, amount, data);
    }

    /// @dev Transfers `amount` of `id` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Reveived}, which is called upon a batch transfer.
    ///
    /// Emits a {Transfer} event.
    function _safeTransfer(
        address by,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            by := shr(96, shl(96, by))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            if iszero(or(iszero(by), eq(by, from))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, toSlotSeed)
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            {
                mstore(0x20, amount)
                log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), from, to)
            }
        }
        if (_hasCode(to)) _checkOnERC1155Received(from, to, id, amount, data);
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, _single(id), _single(amount), data);
        }
    }

    /// @dev Equivalent to `_safeBatchTransfer(address(0), from, to, ids, amounts, data)`.
    function _safeBatchTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _safeBatchTransfer(address(0), from, to, ids, amounts, data);
    }

    /// @dev Transfers `amounts` of `ids` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `ids` and `amounts` must have the same length.
    /// - `from` must have at least `amounts` of `ids`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReveived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function _safeBatchTransfer(
        address by,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            by := shr(96, shl(96, by))
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            if iszero(or(iszero(by), eq(by, from))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                let end := shl(5, mload(ids))
                for { let i := 0 } iszero(eq(i, end)) {} {
                    i := add(i, 0x20)
                    let amount := mload(add(amounts, i))
                    // Subtract and store the updated balance of `from`.
                    {
                        mstore(0x20, fromSlotSeed)
                        mstore(0x00, mload(add(ids, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x20, toSlotSeed)
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), from, to)
            }
        }
        if (_hasCode(to)) _checkOnERC1155BatchReceived(from, to, ids, amounts, data);
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, ids, amounts, data);
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                    HOOKS FOR OVERRIDING                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override this function to return true if `_beforeTokenTransfer` is used.
    /// The is to help the compiler avoid producing dead bytecode.
    function _useBeforeTokenTransfer() internal view virtual returns (bool) {
        return false;
    }

    /// @dev Hook that is called before any token transfer.
    /// This includes minting and burning, as well as batched variants.
    ///
    /// The same hook is called on both single and batched variants.
    /// For single transfers, the length of the `id` and `amount` arrays are 1.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /// @dev Override this function to return true if `_afterTokenTransfer` is used.
    /// The is to help the compiler avoid producing dead bytecode.
    function _useAfterTokenTransfer() internal view virtual returns (bool) {
        return false;
    }

    /// @dev Hook that is called after any token transfer.
    /// This includes minting and burning, as well as batched variants.
    ///
    /// The same hook is called on both single and batched variants.
    /// For single transfers, the length of the `id` and `amount` arrays are 1.
    function _afterTokenTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      PRIVATE HELPERS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Helper for calling the `_afterTokenTransfer` hook.
    /// The is to help the compiler avoid producing dead bytecode.
    function _afterTokenTransferCalldata(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) private {
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, ids, amounts, data);
        }
    }

    /// @dev Returns if `a` has bytecode of non-zero length.
    function _hasCode(address a) private view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := extcodesize(a) // Can handle dirty upper bits.
        }
    }

    /// @dev Perform a call to invoke {IERC1155Receiver-onERC1155Received} on `to`.
    /// Reverts if the target does not support the function correctly.
    function _checkOnERC1155Received(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the calldata.
            let m := mload(0x40)
            let onERC1155ReceivedSelector := 0xf23a6e61
            mstore(m, onERC1155ReceivedSelector)
            mstore(add(m, 0x20), caller())
            mstore(add(m, 0x40), shr(96, shl(96, from)))
            mstore(add(m, 0x60), id)
            mstore(add(m, 0x80), amount)
            mstore(add(m, 0xa0), 0xa0)
            let n := mload(data)
            mstore(add(m, 0xc0), n)
            if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xe0), n)) }
            // Revert if the call reverts.
            if iszero(call(gas(), to, 0, add(m, 0x1c), add(0xc4, n), m, 0x20)) {
                if returndatasize() {
                    // Bubble up the revert if the delegatecall reverts.
                    returndatacopy(0x00, 0x00, returndatasize())
                    revert(0x00, returndatasize())
                }
                mstore(m, 0)
            }
            // Load the returndata and compare it.
            if iszero(eq(mload(m), shl(224, onERC1155ReceivedSelector))) {
                mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Perform a call to invoke {IERC1155Receiver-onERC1155BatchReceived} on `to`.
    /// Reverts if the target does not support the function correctly.
    function _checkOnERC1155BatchReceived(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the calldata.
            let m := mload(0x40)
            let onERC1155BatchReceivedSelector := 0xbc197c81
            mstore(m, onERC1155BatchReceivedSelector)
            mstore(add(m, 0x20), caller())
            mstore(add(m, 0x40), shr(96, shl(96, from)))
            // Copy the `ids`.
            mstore(add(m, 0x60), 0xa0)
            let n := add(0x20, shl(5, mload(ids)))
            let o := add(m, 0xc0)
            pop(staticcall(gas(), 4, ids, n, o, n))
            // Copy the `amounts`.
            let s := add(0xa0, returndatasize())
            mstore(add(m, 0x80), s)
            o := add(o, returndatasize())
            n := add(0x20, shl(5, mload(amounts)))
            pop(staticcall(gas(), 4, amounts, n, o, n))
            // Copy the `data`.
            mstore(add(m, 0xa0), add(s, returndatasize()))
            o := add(o, returndatasize())
            n := add(0x20, mload(data))
            pop(staticcall(gas(), 4, data, n, o, n))
            n := sub(add(o, returndatasize()), add(m, 0x1c))
            // Revert if the call reverts.
            if iszero(call(gas(), to, 0, add(m, 0x1c), n, m, 0x20)) {
                if returndatasize() {
                    // Bubble up the revert if the delegatecall reverts.
                    returndatacopy(0x00, 0x00, returndatasize())
                    revert(0x00, returndatasize())
                }
                mstore(m, 0)
            }
            // Load the returndata and compare it.
            if iszero(eq(mload(m), shl(224, onERC1155BatchReceivedSelector))) {
                mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns `x` in an array with a single element.
    function _single(uint256 x) private pure returns (uint256[] memory result) {
        assembly {
            result := mload(0x40)
            mstore(0x40, add(result, 0x40))
            mstore(result, 1)
            mstore(add(result, 0x20), x)
        }
    }
}

// File: solady/auth/Ownable.sol


pragma solidity ^0.8.4;

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
/// @dev While the ownable portion follows [EIP-173](https://eips.ethereum.org/EIPS/eip-173)
/// for compatibility, the nomenclature for the 2-step ownership handover
/// may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev `bytes4(keccak256(bytes("Unauthorized()")))`.
    uint256 private constant _UNAUTHORIZED_ERROR_SELECTOR = 0x82b42900;

    /// @dev `bytes4(keccak256(bytes("NewOwnerIsZeroAddress()")))`.
    uint256 private constant _NEW_OWNER_IS_ZERO_ADDRESS_ERROR_SELECTOR = 0x7448fbae;

    /// @dev `bytes4(keccak256(bytes("NoHandoverRequest()")))`.
    uint256 private constant _NO_HANDOVER_REQUEST_ERROR_SELECTOR = 0x6f5e8818;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by: `not(_OWNER_SLOT_NOT)`.
    /// It is intentionally choosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    uint256 private constant _OWNER_SLOT_NOT = 0x8b78c6d8;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Clean the upper 96 bits.
            newOwner := shr(96, shl(96, newOwner))
            // Store the new value.
            sstore(not(_OWNER_SLOT_NOT), newOwner)
            // Emit the {OwnershipTransferred} event.
            log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            let ownerSlot := not(_OWNER_SLOT_NOT)
            // Clean the upper 96 bits.
            newOwner := shr(96, shl(96, newOwner))
            // Emit the {OwnershipTransferred} event.
            log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
            // Store the new value.
            sstore(ownerSlot, newOwner)
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(not(_OWNER_SLOT_NOT)))) {
                mstore(0x00, _UNAUTHORIZED_ERROR_SELECTOR)
                revert(0x1c, 0x04)
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        if (newOwner == address(0)) revert NewOwnerIsZeroAddress();
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will be automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to 1.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, _NO_HANDOVER_REQUEST_ERROR_SELECTOR)
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
            // Clean the upper 96 bits.
            let newOwner := shr(96, mload(0x0c))
            // Emit the {OwnershipTransferred} event.
            log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, caller(), newOwner)
            // Store the new value.
            sstore(not(_OWNER_SLOT_NOT), newOwner)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(not(_OWNER_SLOT_NOT))
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    function ownershipHandoverValidFor() public view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

// File: miladycola/cap6.sol

//SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;



contract MiladyColaCapsV2 is ERC1155, Ownable {

    error AdminOnlyMint();

    string public name = "MiladyCola Caps V2";
    string public symbol = "MCC2";
    string public _uri;
    uint256 public count = 485;
    address[3] public admin;

    constructor() {      
        _initializeOwner(msg.sender); 
    }

    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    function setURI(string memory newuri) external onlyOwner {
        _uri = newuri;
    }

    function setAdmin(address newAdmin, uint256 index) public onlyOwner {
        admin[index] = newAdmin;
    }

    function mintLCaps(uint256 numberOfTokens, address player) public payable adminOnly {
        uint256 _count = count;
        for(uint256 i=0; i < numberOfTokens;){
            _mint(player,_count,1,"");
            unchecked {
                ++_count;
                ++i;
            }
        }
        count = _count;
    }
    
    function mintWCap(address player) public payable adminOnly {
        _mint(player, 349, 1, "");
    }

    modifier adminOnly() virtual {
        if(msg.sender!=admin[0] && msg.sender!=admin[1] && msg.sender!=admin[2]){revert AdminOnlyMint();}
        _;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccountBalanceOverflow","type":"error"},{"inputs":[],"name":"AdminOnlyMint","type":"error"},{"inputs":[],"name":"ArrayLengthsMismatch","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferToNonERC1155ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"isApproved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":"amounts","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":"amount","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":"_uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"owners","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"balances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"},{"internalType":"address","name":"player","type":"address"}],"name":"mintLCaps","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"player","type":"address"}],"name":"mintWCap","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownershipHandoverValidFor","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","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":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"isApproved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

61103:1285:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5497:329;;;;;;;;;;-1:-1:-1;5497:329:0;;;;;:::i;:::-;5572:14;5718:5;5714:2;5710:14;5683:25;5680:45;5674:4;5667:59;5753:2;5747:4;5740:16;5802:4;5796;5786:21;5780:28;5770:38;;5497:329;;;;;;;;620:25:1;;;608:2;593:18;5497:329:0;;;;;;;;19826:392;;;;;;;;;;-1:-1:-1;19826:392:0;;;;;:::i;:::-;20149:10;20007:3;20003:21;;;;20143:17;;;20168:10;20162:17;;20140:40;20188:10;20182:17;;;20137:63;;19826:392;;;;1158:14:1;;1151:22;1133:41;;1121:2;1106:18;19826:392:0;993:187:1;61551:89:0;;;;;;;;;;-1:-1:-1;61551:89:0;;;;;:::i;:::-;;:::i;:::-;;61297:26;;;;;;;;;;;;;;;;61188:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;61272:18::-;;;;;;;;;;;;;:::i;61438:105::-;;;;;;;;;;-1:-1:-1;61438:105:0;;;;;:::i;:::-;;:::i;56894:621::-;;;:::i;12401:5994::-;;;;;;;;;;-1:-1:-1;12401:5994:0;;;;;:::i;:::-;;:::i;18548:1064::-;;;;;;;;;;-1:-1:-1;18548:1064:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;61648:110::-;;;;;;;;;;-1:-1:-1;61648:110:0;;;;;:::i;:::-;;:::i;57600:466::-;;;:::i;61766:338::-;;;;;;:::i;:::-;;:::i;56626:102::-;;;:::i;59609:196::-;;;;;;;;;;-1:-1:-1;59766:20:0;59760:27;59609:196;;;6946:42:1;6934:55;;;6916:74;;6904:2;6889:18;59609:196:0;6770:226:1;61236:29:0;;;;;;;;;;;;;:::i;62116:103::-;;;;;;:::i;:::-;;:::i;6450:753::-;;;;;;;;;;-1:-1:-1;6450:753:0;;;;;:::i;:::-;;:::i;61330:23::-;;;;;;;;;;-1:-1:-1;61330:23:0;;;;;:::i;:::-;;:::i;60454:109::-;;;;;;;;;;-1:-1:-1;60454:109:0;;60546:9;7688:50:1;;7676:2;7661:18;60454:109:0;7544:200:1;5920:386:0;;;;;;;;;;-1:-1:-1;5920:386:0;;;;;:::i;:::-;6188:2;6184:14;;;;6157:25;6154:45;6148:4;6141:59;6044:11;6214:22;6282:4;6276;6266:21;6260:28;;5920:386;58257:1008;;;;;;:::i;:::-;;:::i;7695:4144::-;;;;;;;;;;-1:-1:-1;7695:4144:0;;;;;:::i;:::-;;:::i;56373:185::-;;;;;;:::i;:::-;;:::i;59911:449::-;;;;;;;;;;-1:-1:-1;59911:449:0;;;;;:::i;:::-;60190:19;60184:4;60177:33;;;60034:14;60224:26;;;;60336:4;60320:21;;60314:28;;59911:449;61551:89;60960:13;:11;:13::i;:::-;61619:4:::1;:13;61626:6:::0;61619:4;:13:::1;:::i;:::-;;61551:89:::0;:::o;61188:41::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;61272:18::-;;;;;;;:::i;61438:105::-;61498:13;61531:4;61524:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61438:105;;;:::o;56894:621::-;56989:15;60546:9;57007:45;;:15;:45;56989:63;;57216:19;57210:4;57203:33;57267:8;57261:4;57254:22;57324:7;57317:4;57311;57301:21;57294:38;57473:8;57426:45;57423:1;57420;57415:67;57124:373;56894:621::o;12401:5994::-;12820:14;12808:10;12805:30;12795:165;;12869:10;12863:4;12856:24;12940:4;12934;12927:18;12795:165;13032:4;13028:2;13024:13;12997:25;12994:44;13108:2;13104;13100:11;13073:25;13070:42;13139:12;13133:4;13126:26;13223:12;13219:2;13215:21;13207:29;;13264:10;13260:2;13256:19;13250:25;;13351:2;13341:138;;13387:10;13381:4;13374:24;13459:4;13453;13446:18;13341:138;13589:4;13579:8;13576:18;13566:278;;13628:8;13622:4;13615:22;13687:4;13681;13671:21;13665:28;13655:174;;13731:10;13725:4;13718:24;13805:4;13799;13792:18;13655:174;13963:10;13960:1;13956:18;14007:1;13992:1489;14024:3;14021:1;14018:10;13992:1489;;14122:1;14106:14;14102:22;14089:36;14261:12;14255:4;14248:26;14342:1;14330:10;14326:18;14313:32;14307:4;14300:46;14411:4;14405;14395:21;14467:15;14461:22;14523:11;14515:6;14512:23;14509:185;;;14580:10;14574:4;14567:24;14662:4;14656;14649:18;14509:185;14744:24;;;14720:49;;14920:4;14913:24;;;15000:4;14994;14984:21;15054:20;;15122:28;;;15179:35;;;15176:200;;;15259:10;15253:4;15246:24;15344:4;15338;15331:18;15176:200;15402:37;;;-1:-1:-1;;14044:4:0;14037:12;13992:1489;;;13996:14;;13926:1570;;15590:4;15584:11;15659:4;15656:1;15649:15;15708:10;15705:1;15701:18;15695:4;15691:29;15754:4;15751:1;15747:12;15816:1;15809:4;15797:10;15793:21;15790:1;15777:41;15901:4;15897:12;;15890:4;15883:12;;;15876:34;;;;15979:1;15975:22;;;15965:33;;15933:9;15965:33;16032:25;;;15933:9;16016:45;16088:9;16084:17;;;16212:2;16206:4;16196:8;16163:31;16084:17;16099:1;16152:63;;;16255:24;43131:4;43065:103;;16255:24;16251:114;;;16296:57;16324:4;16330:2;16334:3;;16339:7;;16348:4;;16296:27;:57::i;:::-;16541:2;16529:15;16526:1851;;;16579:4;16573:11;16682:10;16720:30;16717:1;16710:41;16790:8;16783:4;16780:1;16776:12;16769:30;16838:4;16831;16828:1;16824:12;16817:26;16918:4;16911;16908:1;16904:12;16897:26;16967:10;16964:1;16960:18;16954:4;16950:29;17013:4;17010:1;17006:12;17075:1;17068:4;17056:10;17052:21;17049:1;17036:41;17154:1;17148:4;17144:12;17195:1;17188:4;17185:1;17181:12;17174:23;17227:1;17224;17220:9;17215:14;;17269;17266:1;17262:22;17256:4;17252:33;17247:38;;17346:1;17339:4;17323:14;17319:25;17316:1;17303:45;17424:9;;17417:4;17410:12;;17403:31;17493:4;17489:22;;;17457:9;17489:22;17545;;;17457:9;17529:42;17598:9;17594:28;;;;;17737:4;17594:28;;17616:4;17609:12;;17714:1;17710:2;17703:5;17698:44;17688:380;;17770:16;17767:248;;;17919:16;17913:4;17907;17892:44;17975:16;17969:4;17962:30;17767:248;18047:1;18044;18037:12;17688:380;;18174:30;18169:3;18165:40;18161:1;18155:8;18152:54;18142:220;;18244:10;18238:4;18231:24;18338:4;18332;18325:18;18142:220;;;16526:1851;12401:5994;;;;;;;;:::o;18548:1064::-;18688:25;18824:13;18812:10;18809:29;18799:164;;18872:10;18866:4;18859:24;18943:4;18937;18930:18;18799:164;18995:4;18989:11;18977:23;;19031:10;19021:8;19014:28;19079:4;19069:8;19065:19;19116:10;19113:1;19109:18;19163:1;19158:3;19154:11;19148:4;19141:25;19261:1;19246:348;19278:3;19275:1;19272:10;19246:348;;19407:25;19351:21;;;19338:35;19438:2;19434:14;19404:45;19398:4;19391:59;;;19494:18;;;19481:32;19475:4;19468:46;;;19572:4;19556:21;;19550:28;19539:9;;;19532:47;19291:12;19246:348;;;19250:14;;;18548:1064;;;;;;:::o;61648:110::-;60960:13;:11;:13::i;:::-;61742:8:::1;61727:5;61733;61727:12;;;;;;;:::i;:::-;;:23:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;61648:110:0:o;57600:466::-;57806:19;57800:4;57793:33;57853:8;57847:4;57840:22;57906:1;57899:4;57893;57883:21;57876:32;58039:8;57993:44;57990:1;57987;57982:66;57600:466::o;61766:338::-;62282:5;62288:1;62282:8;;;;62270:10;:20;;;;:44;;-1:-1:-1;62306:5:0;62312:1;62306:8;;;;62294:10;:20;;62270:44;:68;;;;-1:-1:-1;62330:5:0;62336:1;62330:8;;;;62318:10;:20;;62270:68;62267:97;;;62347:15;;;;;;;;;;;;;;62267:97;61878:5:::1;::::0;61861:14:::1;61894:178;61915:14;61911:1;:18;61894:178;;;61946:25;61952:6;61959;61966:1;61946:25;;;;;;;;;;;::::0;:5:::1;:25::i;:::-;62015:8;::::0;;::::1;::::0;62042:3:::1;61894:178;;;-1:-1:-1::0;62082:5:0::1;:14:::0;-1:-1:-1;;61766:338:0:o;56626:102::-;60960:13;:11;:13::i;:::-;56699:21:::1;56717:1;56699:9;:21::i;:::-;56626:102::o:0;61236:29::-;;;;;;;:::i;62116:103::-;62282:5;62288:1;62282:8;;;;62270:10;:20;;;;:44;;-1:-1:-1;62306:5:0;62312:1;62306:8;;;;62294:10;:20;;62270:44;:68;;;;-1:-1:-1;62330:5:0;62336:1;62330:8;;;;62318:10;:20;;62270:68;62267:97;;;62347:15;;;;;;;;;;;;;;62267:97;62186:25:::1;62192:6;62200:3;62205:1;62186:25;;;;;;;;;;;::::0;:5:::1;:25::i;:::-;62116:103:::0;:::o;6450:753::-;6675:8;6671:2;6667:17;6663:2;6659:26;6647:38;;6762:10;6755:18;6748:26;6734:40;;6911:8;6907:2;6903:17;6876:25;6873:48;6867:4;6860:62;6949:8;6943:4;6936:22;7002:10;6995:4;6989;6979:21;6972:41;7089:10;7083:4;7076:24;7176:8;7166;7131:33;7125:4;7119;7114:71;6450:753;;:::o;61330:23::-;;;;;;;;;;;;;;;;;-1:-1:-1;61330:23:0;:::o;58257:1008::-;60960:13;:11;:13::i;:::-;58495:19:::1;58489:4;58482:33;58542:12;58536:4;58529:26;58605:4;58599;58589:21;58713:12;58707:19;58694:11;58691:36;58688:159;;;58760:35;58754:4;58747:49;58827:4;58821;58814:18;58688:159;58926:1;58912:12;58905:23;;59013:4;59007:11;59003:2;58999:20;59149:8;59139;59099:38;59096:1;59093::::0;59088:70:::1;59216:20:::0;59209:38;-1:-1:-1;58257:1008:0:o;7695:4144::-;8134:4;8130:2;8126:13;8099:25;8096:44;8210:2;8206;8202:11;8175:25;8172:42;8241:12;8235:4;8228:26;8325:12;8321:2;8317:21;8309:29;;8366:10;8362:2;8358:19;8352:25;;8487:4;8477:8;8474:18;8464:278;;8526:8;8520:4;8513:22;8585:4;8579;8569:21;8563:28;8553:174;;8629:10;8623:4;8616:24;8703:4;8697;8690:18;8553:174;8818:2;8808:138;;8854:10;8848:4;8841:24;8926:4;8920;8913:18;8808:138;9058:2;9052:4;9045:16;9118:4;9112;9102:21;9079:44;;9166:15;9160:22;9214:11;9206:6;9203:23;9200:161;;;9263:10;9257:4;9250:24;9337:4;9331;9324:18;9200:161;9420:6;9407:11;9403:24;9386:15;9379:49;;9553:10;9547:4;9540:24;9619:4;9613;9603:21;9582:42;;9671:13;9665:20;9746:6;9729:15;9725:28;9793:15;9777:14;9774:35;9771:176;;;9846:10;9840:4;9833:24;9923:4;9917;9910:18;9771:176;9965:37;;;-1:-1:-1;;10104:4:0;10097:20;;;10202:2;10196:4;10186:8;10152:32;10146:4;10140;10135:70;10534:2;10522:15;10519:1302;;;10614:4;10608:11;10670:10;10708:25;10705:1;10698:36;10773:8;10766:4;10763:1;10759:12;10752:30;10821:4;10814;10811:1;10807:12;10800:26;10865:2;10858:4;10855:1;10851:12;10844:24;10907:6;10900:4;10897:1;10893:12;10886:28;10953:4;10946;10943:1;10939:12;10932:26;11037:11;11031:4;11027:22;11020:4;11007:11;11003:22;10996:4;10993:1;10989:12;10976:74;11186:4;11183:1;11169:11;11163:4;11159:22;11152:4;11149:1;11145:12;11142:1;11138:2;11131:5;11126:65;11116:401;;11219:16;11216:248;;;11368:16;11362:4;11356;11341:44;11424:16;11418:4;11411:30;11216:248;11496:1;11493;11486:12;11116:401;11623:25;11618:3;11614:35;11610:1;11604:8;11601:49;11591:215;;11688:10;11682:4;11675:24;11782:4;11776;11769:18;10519:1302;7695:4144;;;;;;:::o;56373:185::-;60960:13;:11;:13::i;:::-;56466:22:::1;::::0;::::1;56462:58;;56497:23;;;;;;;;;;;;;;56462:58;56531:19;56541:8;56531:9;:19::i;55636:370::-:0;55852:20;55846:27;55836:8;55833:41;55823:165;;55908:28;55902:4;55895:42;55968:4;55962;55955:18;44850:320;45057:106;;20823:1738;20925:130;;21021:15;43470:194;;;;;20971:72;21189:2;21185;21181:11;21154:25;21151:42;21262:10;21258:2;21254:19;21248:25;;21349:2;21339:138;;21385:10;21379:4;21372:24;21457:4;21451;21444:18;21339:138;21587:10;21581:4;21574:24;21629:2;21623:4;21616:16;21687:4;21681;21671:21;21739:13;21733:20;21814:6;21797:15;21793:28;21861:15;21845:14;21842:35;21839:176;;;21914:10;21908:4;21901:24;21991:4;21985;21978:18;21839:176;22055:14;22040:13;22033:37;;;;21555:530;22178:2;22172:4;22165:16;22212:6;22206:4;22199:20;22301:2;22298:1;22288:8;22254:32;22248:4;22242;22237:67;45393:14;;22478:75;;;22496:57;22528:1;22532:2;22536;22540:6;22548:4;22496:23;:57::i;55069:506::-;55219:20;55452:16;;55306:26;;;;;;;55412:38;55409:1;;55401:78;55530:27;55069:506::o;45622:1496::-;45920:4;45914:11;45972:10;46006:25;46003:1;45996:36;46067:8;46060:4;46057:1;46053:12;46046:30;46127:4;46123:2;46119:13;46115:2;46111:22;46104:4;46101:1;46097:12;46090:44;46169:2;46162:4;46159:1;46155:12;46148:24;46207:6;46200:4;46197:1;46193:12;46186:28;46249:4;46242;46239:1;46235:12;46228:26;46283:4;46277:11;46323:1;46316:4;46313:1;46309:12;46302:23;46342:1;46339:71;;;46405:1;46398:4;46395:1;46391:12;46388:1;46381:4;46375;46371:15;46368:1;46361:5;46350:57;46346:62;46339:71;46528:4;46525:1;46521;46515:4;46511:12;46504:4;46501:1;46497:12;46494:1;46490:2;46483:5;46478:55;46468:363;;46557:16;46554:232;;;46698:16;46692:4;46686;46671:44;46750:16;46744:4;46737:30;46554:232;46814:1;46811;46804:12;46468:363;;46929:25;46924:3;46920:35;46916:1;46910:8;46907:49;46897:203;;46990:10;46984:4;46977:24;47080:4;47074;47067:18;46897:203;;;45622:1496;;;;;:::o;14:196:1:-;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:254::-;283:6;291;344:2;332:9;323:7;319:23;315:32;312:52;;;360:1;357;350:12;312:52;383:29;402:9;383:29;:::i;:::-;373:39;459:2;444:18;;;;431:32;;-1:-1:-1;;;215:254:1:o;656:332::-;714:6;767:2;755:9;746:7;742:23;738:32;735:52;;;783:1;780;773:12;735:52;822:9;809:23;872:66;865:5;861:78;854:5;851:89;841:117;;954:1;951;944:12;841:117;977:5;656:332;-1:-1:-1;;;656:332:1:o;1185:184::-;1237:77;1234:1;1227:88;1334:4;1331:1;1324:15;1358:4;1355:1;1348:15;1374:981;1443:6;1496:2;1484:9;1475:7;1471:23;1467:32;1464:52;;;1512:1;1509;1502:12;1464:52;1552:9;1539:23;1581:18;1622:2;1614:6;1611:14;1608:34;;;1638:1;1635;1628:12;1608:34;1676:6;1665:9;1661:22;1651:32;;1721:7;1714:4;1710:2;1706:13;1702:27;1692:55;;1743:1;1740;1733:12;1692:55;1779:2;1766:16;1801:2;1797;1794:10;1791:36;;;1807:18;;:::i;:::-;1941:2;1935:9;2003:4;1995:13;;1846:66;1991:22;;;2015:2;1987:31;1983:40;1971:53;;;2039:18;;;2059:22;;;2036:46;2033:72;;;2085:18;;:::i;:::-;2125:10;2121:2;2114:22;2160:2;2152:6;2145:18;2200:7;2195:2;2190;2186;2182:11;2178:20;2175:33;2172:53;;;2221:1;2218;2211:12;2172:53;2277:2;2272;2268;2264:11;2259:2;2251:6;2247:15;2234:46;2322:1;2300:15;;;2317:2;2296:24;2289:35;;;;-1:-1:-1;2304:6:1;1374:981;-1:-1:-1;;;;;1374:981:1:o;2360:607::-;2472:4;2501:2;2530;2519:9;2512:21;2562:6;2556:13;2605:6;2600:2;2589:9;2585:18;2578:34;2630:1;2640:140;2654:6;2651:1;2648:13;2640:140;;;2749:14;;;2745:23;;2739:30;2715:17;;;2734:2;2711:26;2704:66;2669:10;;2640:140;;;2644:3;2829:1;2824:2;2815:6;2804:9;2800:22;2796:31;2789:42;2958:2;2888:66;2883:2;2875:6;2871:15;2867:88;2856:9;2852:104;2848:113;2840:121;;;;2360:607;;;;:::o;2972:180::-;3031:6;3084:2;3072:9;3063:7;3059:23;3055:32;3052:52;;;3100:1;3097;3090:12;3052:52;-1:-1:-1;3123:23:1;;2972:180;-1:-1:-1;2972:180:1:o;3157:367::-;3220:8;3230:6;3284:3;3277:4;3269:6;3265:17;3261:27;3251:55;;3302:1;3299;3292:12;3251:55;-1:-1:-1;3325:20:1;;3368:18;3357:30;;3354:50;;;3400:1;3397;3390:12;3354:50;3437:4;3429:6;3425:17;3413:29;;3497:3;3490:4;3480:6;3477:1;3473:14;3465:6;3461:27;3457:38;3454:47;3451:67;;;3514:1;3511;3504:12;3451:67;3157:367;;;;;:::o;3529:347::-;3580:8;3590:6;3644:3;3637:4;3629:6;3625:17;3621:27;3611:55;;3662:1;3659;3652:12;3611:55;-1:-1:-1;3685:20:1;;3728:18;3717:30;;3714:50;;;3760:1;3757;3750:12;3714:50;3797:4;3789:6;3785:17;3773:29;;3849:3;3842:4;3833:6;3825;3821:19;3817:30;3814:39;3811:59;;;3866:1;3863;3856:12;3881:1210;4041:6;4049;4057;4065;4073;4081;4089;4097;4150:3;4138:9;4129:7;4125:23;4121:33;4118:53;;;4167:1;4164;4157:12;4118:53;4190:29;4209:9;4190:29;:::i;:::-;4180:39;;4238:38;4272:2;4261:9;4257:18;4238:38;:::i;:::-;4228:48;;4327:2;4316:9;4312:18;4299:32;4350:18;4391:2;4383:6;4380:14;4377:34;;;4407:1;4404;4397:12;4377:34;4446:70;4508:7;4499:6;4488:9;4484:22;4446:70;:::i;:::-;4535:8;;-1:-1:-1;4420:96:1;-1:-1:-1;4623:2:1;4608:18;;4595:32;;-1:-1:-1;4639:16:1;;;4636:36;;;4668:1;4665;4658:12;4636:36;4707:72;4771:7;4760:8;4749:9;4745:24;4707:72;:::i;:::-;4798:8;;-1:-1:-1;4681:98:1;-1:-1:-1;4886:3:1;4871:19;;4858:33;;-1:-1:-1;4903:16:1;;;4900:36;;;4932:1;4929;4922:12;4900:36;;4971:60;5023:7;5012:8;5001:9;4997:24;4971:60;:::i;:::-;3881:1210;;;;-1:-1:-1;3881:1210:1;;-1:-1:-1;3881:1210:1;;;;;;5050:8;-1:-1:-1;;;3881:1210:1:o;5096:773::-;5218:6;5226;5234;5242;5295:2;5283:9;5274:7;5270:23;5266:32;5263:52;;;5311:1;5308;5301:12;5263:52;5351:9;5338:23;5380:18;5421:2;5413:6;5410:14;5407:34;;;5437:1;5434;5427:12;5407:34;5476:70;5538:7;5529:6;5518:9;5514:22;5476:70;:::i;:::-;5565:8;;-1:-1:-1;5450:96:1;-1:-1:-1;5653:2:1;5638:18;;5625:32;;-1:-1:-1;5669:16:1;;;5666:36;;;5698:1;5695;5688:12;5666:36;;5737:72;5801:7;5790:8;5779:9;5775:24;5737:72;:::i;:::-;5096:773;;;;-1:-1:-1;5828:8:1;-1:-1:-1;;;;5096:773:1:o;5874:632::-;6045:2;6097:21;;;6167:13;;6070:18;;;6189:22;;;6016:4;;6045:2;6268:15;;;;6242:2;6227:18;;;6016:4;6311:169;6325:6;6322:1;6319:13;6311:169;;;6386:13;;6374:26;;6455:15;;;;6420:12;;;;6347:1;6340:9;6311:169;;;-1:-1:-1;6497:3:1;;5874:632;-1:-1:-1;;;;;;5874:632:1:o;6511:254::-;6579:6;6587;6640:2;6628:9;6619:7;6615:23;6611:32;6608:52;;;6656:1;6653;6646:12;6608:52;6692:9;6679:23;6669:33;;6721:38;6755:2;6744:9;6740:18;6721:38;:::i;:::-;6711:48;;6511:254;;;;;:::o;7001:186::-;7060:6;7113:2;7101:9;7092:7;7088:23;7084:32;7081:52;;;7129:1;7126;7119:12;7081:52;7152:29;7171:9;7152:29;:::i;7192:347::-;7257:6;7265;7318:2;7306:9;7297:7;7293:23;7289:32;7286:52;;;7334:1;7331;7324:12;7286:52;7357:29;7376:9;7357:29;:::i;:::-;7347:39;;7436:2;7425:9;7421:18;7408:32;7483:5;7476:13;7469:21;7462:5;7459:32;7449:60;;7505:1;7502;7495:12;7449:60;7528:5;7518:15;;;7192:347;;;;;:::o;7749:260::-;7817:6;7825;7878:2;7866:9;7857:7;7853:23;7849:32;7846:52;;;7894:1;7891;7884:12;7846:52;7917:29;7936:9;7917:29;:::i;:::-;7907:39;;7965:38;7999:2;7988:9;7984:18;7965:38;:::i;8014:695::-;8120:6;8128;8136;8144;8152;8160;8213:3;8201:9;8192:7;8188:23;8184:33;8181:53;;;8230:1;8227;8220:12;8181:53;8253:29;8272:9;8253:29;:::i;:::-;8243:39;;8301:38;8335:2;8324:9;8320:18;8301:38;:::i;:::-;8291:48;;8386:2;8375:9;8371:18;8358:32;8348:42;;8437:2;8426:9;8422:18;8409:32;8399:42;;8492:3;8481:9;8477:19;8464:33;8520:18;8512:6;8509:30;8506:50;;;8552:1;8549;8542:12;8506:50;8591:58;8641:7;8632:6;8621:9;8617:22;8591:58;:::i;:::-;8014:695;;;;-1:-1:-1;8014:695:1;;-1:-1:-1;8014:695:1;;8668:8;;8014:695;-1:-1:-1;;;8014:695:1:o;8714:437::-;8793:1;8789:12;;;;8836;;;8857:61;;8911:4;8903:6;8899:17;8889:27;;8857:61;8964:2;8956:6;8953:14;8933:18;8930:38;8927:218;;9001:77;8998:1;8991:88;9102:4;9099:1;9092:15;9130:4;9127:1;9120:15;8927:218;;8714:437;;;:::o;9282:545::-;9384:2;9379:3;9376:11;9373:448;;;9420:1;9445:5;9441:2;9434:17;9490:4;9486:2;9476:19;9560:2;9548:10;9544:19;9541:1;9537:27;9531:4;9527:38;9596:4;9584:10;9581:20;9578:47;;;-1:-1:-1;9619:4:1;9578:47;9674:2;9669:3;9665:12;9662:1;9658:20;9652:4;9648:31;9638:41;;9729:82;9747:2;9740:5;9737:13;9729:82;;;9792:17;;;9773:1;9762:13;9729:82;;9373:448;9282:545;;;:::o;10063:1471::-;10189:3;10183:10;10216:18;10208:6;10205:30;10202:56;;;10238:18;;:::i;:::-;10267:97;10357:6;10317:38;10349:4;10343:11;10317:38;:::i;:::-;10311:4;10267:97;:::i;:::-;10419:4;;10483:2;10472:14;;10500:1;10495:782;;;;11321:1;11338:6;11335:89;;;-1:-1:-1;11390:19:1;;;11384:26;11335:89;9969:66;9960:1;9956:11;;;9952:84;9948:89;9938:100;10044:1;10040:11;;;9935:117;11437:81;;10465:1063;;10495:782;9229:1;9222:14;;;9266:4;9253:18;;10543:66;10531:79;;;10708:236;10722:7;10719:1;10716:14;10708:236;;;10811:19;;;10805:26;10790:42;;10903:27;;;;10871:1;10859:14;;;;10738:19;;10708:236;;;10712:3;10972:6;10963:7;10960:19;10957:261;;;11033:19;;;11027:26;11134:66;11116:1;11112:14;;;11128:3;11108:24;11104:97;11100:102;11085:118;11070:134;;10957:261;-1:-1:-1;;;;;11264:1:1;11248:14;;;11244:22;11231:36;;-1:-1:-1;10063:1471:1:o;11539:184::-;11591:77;11588:1;11581:88;11688:4;11685:1;11678:15;11712:4;11709:1;11702:15

ipfs://a7adbd58931ee773956568080d46051f41aed5b65b549e2710a81cfed6c407bf