Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library MerkleProofLib    - function verify(bytes32[] memory proo ...    - function verifyCalldata(bytes32[] cal ...    - function verifyMultiProof(    - function verifyMultiProofCalldata(    - function emptyProof()    - function emptyLeaves()    - function emptyFlags()    - function _initializeOwner(address new ...    - function _setOwner(address newOwner)    - function _checkOwner()    - function _ownershipHandoverValidFor()    - function transferOwnership(address ne ...    - function renounceOwnership()    - function requestOwnershipHandover()    - function cancelOwnershipHandover()    - function completeOwnershipHandover(ad ...    - function owner()    - function ownershipHandoverExpiresAt(a ... interface IERC721A    - function totalSupply()    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(    - function safeTransferFrom(    - function transferFrom(    - function approve(address to, uint256 ...    - function setApprovalForAll(address op ...    - function getApproved(uint256 tokenId)    - function isApprovedForAll(address own ...    - function name()    - function symbol()    - function tokenURI(uint256 tokenId) interface IERC721ABurnable is IERC721 ...    - function burn(uint256 tokenId) interface IERC721AQueryable is IERC72 ...    - function explicitOwnershipOf(uint256 ...    - function explicitOwnershipsOf(uint256 ...    - function tokensOfOwnerIn(    - function tokensOfOwner(address owner) interface ERC721A__IERC721Receiver    - function onERC721Received(  contract ERC721A is IERC721A    - function _startTokenId()    - function _nextTokenId()    - function totalSupply()    - function _totalMinted()    - function _totalBurned()    - function balanceOf(address owner)    - function _numberMinted(address owner)    - function _numberBurned(address owner)    - function _getAux(address owner)    - function _setAux(address owner, uint6 ...    - function supportsInterface(bytes4 int ...    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function ownerOf(uint256 tokenId)    - function _ownershipOf(uint256 tokenId ...    - function _ownershipAt(uint256 index)    - function _initializeOwnershipAt(uint2 ...    - function _packedOwnershipOf(uint256 t ...    - function _unpackedOwnership(uint256 p ...    - function _packOwnershipData(address o ...    - function _nextInitializedFlag(uint256 ...    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function _exists(uint256 tokenId)    - function _isSenderApprovedOrOwner(    - function _getApprovedSlotAndAddress(u ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _beforeTokenTransfers(    - function _afterTokenTransfers(    - function _checkContractOnERC721Receiv ...    - function _mint(address to, uint256 qu ...    - function _mintERC2309(address to, uin ...    - function _safeMint(    - function _safeMint(address to, uint25 ...    - function _burn(uint256 tokenId)    - function _burn(uint256 tokenId, bool ...    - function _setExtraDataAt(uint256 inde ...    - function _extraData(    - function _nextExtraData(    - function _msgSenderERC721A()    - function _toString(uint256 value)    - function burn(uint256 tokenId)    - function explicitOwnershipOf(uint256 ...    - function explicitOwnershipsOf(uint256 ...    - function tokensOfOwnerIn(    - function tokensOfOwner(address owner)  contract TubbyStation is ERC721A, ... *    - function _startTokenId()    - function configure(bytes32 newRoot, s ...    - function _baseURI()    - function withdraw()    - function flipSaleState()    - function checkList(bytes32[] calldata ...    - function mint(uint256 amount)    - function freeMint(bytes32[] calldata ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: solady/src/utils/MerkleProofLib.sol


pragma solidity ^0.8.4;

/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(proof) {
                // Initialize `offset` to the offset of `proof` elements in memory.
                let offset := add(proof, 0x20)
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(offset, shl(5, mload(proof)))
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, mload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), mload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if proof.length {
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(proof.offset, shl(5, proof.length))
                // Initialize `offset` to the offset of `proof` in the calldata.
                let offset := proof.offset
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, calldataload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), calldataload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - The sum of the lengths of `proof` and `leaves` must never overflow.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The memory offset of `proof` must be be non-zero
    ///   (i.e. `proof` is not pointing to the scratch space).
    function verifyMultiProof(
        bytes32[] memory proof,
        bytes32 root,
        bytes32[] memory leaves,
        bool[] memory flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // Cache the lengths of the arrays.
            let leavesLength := mload(leaves)
            let proofLength := mload(proof)
            let flagsLength := mload(flags)

            // Advance the pointers of the arrays to point to the data.
            leaves := add(0x20, leaves)
            proof := add(0x20, proof)
            flags := add(0x20, flags)

            // If the number of flags is correct.
            for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flagsLength) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    isValid := eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof, shl(5, proofLength))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                leavesLength := shl(5, leavesLength)
                for { let i := 0 } iszero(eq(i, leavesLength)) { i := add(i, 0x20) } {
                    mstore(add(hashesFront, i), mload(add(leaves, i)))
                }
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, leavesLength)
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flagsLength := add(hashesBack, shl(5, flagsLength))

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(mload(flags)) {
                        // Loads the next proof.
                        b := mload(proof)
                        proof := add(proof, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag.
                    flags := add(flags, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flagsLength)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof)
                    )
                break
            }
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The calldata offset of `proof` must be non-zero
    ///   (i.e. `proof` is from a regular Solidity function with a 4-byte selector).
    function verifyMultiProofCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32[] calldata leaves,
        bool[] calldata flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // If the number of flags is correct.
            for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flags.length) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    // forgefmt: disable-next-item
                    isValid := eq(
                        calldataload(
                            xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
                        ),
                        root
                    )
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof.offset, shl(5, proof.length))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, shl(5, leaves.length))
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flags.length := add(hashesBack, shl(5, flags.length))

                // We don't need to make a copy of `proof.offset` or `flags.offset`,
                // as they are pass-by-value (this trick may not always save gas).

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(calldataload(flags.offset)) {
                        // Loads the next proof.
                        b := calldataload(proof.offset)
                        proof.offset := add(proof.offset, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag offset.
                    flags.offset := add(flags.offset, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flags.length)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof.offset)
                    )
                break
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   EMPTY CALLDATA HELPERS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns an empty calldata bytes32 array.
    function emptyProof() internal pure returns (bytes32[] calldata proof) {
        /// @solidity memory-safe-assembly
        assembly {
            proof.length := 0
        }
    }

    /// @dev Returns an empty calldata bytes32 array.
    function emptyLeaves() internal pure returns (bytes32[] calldata leaves) {
        /// @solidity memory-safe-assembly
        assembly {
            leaves.length := 0
        }
    }

    /// @dev Returns an empty calldata bool array.
    function emptyFlags() internal pure returns (bool[] calldata flags) {
        /// @solidity memory-safe-assembly
        assembly {
            flags.length := 0
        }
    }
}

// File: solady/src/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 Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// 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();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           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 chosen 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, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

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

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _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 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 `expires`.
                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, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   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))
        }
    }

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

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

// File: erc721a/contracts/IERC721A.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of ERC721A.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error MintERC2309QuantityExceedsLimit();

    /**
     * The `extraData` cannot be set on an unintialized ownership slot.
     */
    error OwnershipNotInitializedForExtraData();

    // =============================================================
    //                            STRUCTS
    // =============================================================

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Stores the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
        uint24 extraData;
    }

    // =============================================================
    //                         TOKEN COUNTERS
    // =============================================================

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() external view returns (uint256);

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

    // =============================================================
    //                            IERC721
    // =============================================================

    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables
     * (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in `owner`'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`,
     * checking first that contract recipients are aware of the ERC721 protocol
     * to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move
     * this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement
     * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external payable;

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external payable;

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
     * whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token
     * by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external payable;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the
     * zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external payable;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom}
     * for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);

    // =============================================================
    //                           IERC2309
    // =============================================================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}

// File: erc721a/contracts/interfaces/IERC721ABurnable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of ERC721ABurnable.
 */
interface IERC721ABurnable is IERC721A {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) external;
}

// File: erc721a/contracts/interfaces/IERC721AQueryable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of ERC721AQueryable.
 */
interface IERC721AQueryable is IERC721A {
    /**
     * Invalid query range (`start` >= `stop`).
     */
    error InvalidQueryRange();

    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *
     * - `addr = address(0)`
     * - `startTimestamp = 0`
     * - `burned = false`
     * - `extraData = 0`
     *
     * If the `tokenId` is burned:
     *
     * - `addr = <Address of owner before token was burned>`
     * - `startTimestamp = <Timestamp when token was burned>`
     * - `burned = true`
     * - `extraData = <Extra data when token was burned>`
     *
     * Otherwise:
     *
     * - `addr = <Address of owner>`
     * - `startTimestamp = <Timestamp of start of ownership>`
     * - `burned = false`
     * - `extraData = <Extra data at start of ownership>`
     */
    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view returns (uint256[] memory);

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner) external view returns (uint256[] memory);
}

// File: erc721a/contracts/ERC721A.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;


/**
 * @dev Interface of ERC721 token receiver.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @title ERC721A
 *
 * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
 * Non-Fungible Token Standard, including the Metadata extension.
 * Optimized for lower gas during batch mints.
 *
 * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
 * starting from `_startTokenId()`.
 *
 * Assumptions:
 *
 * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
    struct TokenApprovalRef {
        address value;
    }

    // =============================================================
    //                           CONSTANTS
    // =============================================================

    // Mask of an entry in packed address data.
    uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant _BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant _BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant _BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant _BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant _BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The bit position of `extraData` in packed ownership.
    uint256 private constant _BITPOS_EXTRA_DATA = 232;

    // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
    uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;

    // The maximum `quantity` that can be minted with {_mintERC2309}.
    // This limit is to prevent overflows on the address data entries.
    // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
    // is required to cause an overflow, which is unrealistic.
    uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;

    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // =============================================================
    //                            STORAGE
    // =============================================================

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned.
    // See {_packedOwnershipOf} implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    // - [232..255] `extraData`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

    // Mapping from token ID to approved address.
    mapping(uint256 => TokenApprovalRef) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // =============================================================
    //                          CONSTRUCTOR
    // =============================================================

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    // =============================================================
    //                   TOKEN COUNTING OPERATIONS
    // =============================================================

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view virtual returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view virtual returns (uint256) {
        // Counter underflow is impossible as `_currentIndex` does not decrement,
        // and it is initialized to `_startTokenId()`.
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view virtual returns (uint256) {
        return _burnCounter;
    }

    // =============================================================
    //                    ADDRESS DATA OPERATIONS
    // =============================================================

    /**
     * @dev Returns the number of tokens in `owner`'s account.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
    }

    /**
     * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal virtual {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        // Cast `aux` with assembly to avoid redundant masking.
        assembly {
            auxCasted := aux
        }
        packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes
        // of the XOR of all function selectors in the interface.
        // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
        // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

    /**
     * @dev Returns the token collection name.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, it can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    // =============================================================
    //                     OWNERSHIPS OPERATIONS
    // =============================================================

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

    /**
     * @dev Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around over time.
     */
    function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal virtual {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & _BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an initialized ownership slot
                        // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
                        // before an unintialized ownership slot
                        // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
                        // Hence, `curr` will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed will be zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
        ownership.burned = packed & _BITMASK_BURNED != 0;
        ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
    }

    /**
     * @dev Packs ownership data into a single uint256.
     */
    function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
            result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
        }
    }

    /**
     * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
    function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
        // For branchless setting of the `nextInitialized` flag.
        assembly {
            // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
            result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
        }
    }

    // =============================================================
    //                      APPROVAL OPERATIONS
    // =============================================================

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the
     * zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) public payable virtual override {
        address owner = ownerOf(tokenId);

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

        _tokenApprovals[tokenId].value = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId].value;
    }

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom}
     * for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted. See {_mint}.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
     */
    function _isSenderApprovedOrOwner(
        address approvedAddress,
        address owner,
        address msgSender
    ) private pure returns (bool result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
            msgSender := and(msgSender, _BITMASK_ADDRESS)
            // `msgSender == owner || msgSender == approvedAddress`.
            result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
        }
    }

    /**
     * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
    function _getApprovedSlotAndAddress(uint256 tokenId)
        private
        view
        returns (uint256 approvedAddressSlot, address approvedAddress)
    {
        TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
        // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
        assembly {
            approvedAddressSlot := tokenApproval.slot
            approvedAddress := sload(approvedAddressSlot)
        }
    }

    // =============================================================
    //                      TRANSFER OPERATIONS
    // =============================================================

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token
     * by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public payable virtual override {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        // The nested ifs save around 20+ gas over a compound boolean condition.
        if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
            if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();

        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
        unchecked {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                to,
                _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public payable virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token
     * by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement
     * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public payable virtual override {
        transferFrom(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token IDs
     * are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * `startTokenId` - the first token ID to be transferred.
     * `quantity` - the amount to be transferred.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token IDs
     * have been transferred. This includes minting.
     * And also called after one token has been burned.
     *
     * `startTokenId` - the first token ID to be transferred.
     * `quantity` - the amount to be transferred.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * `from` - Previous owner of the given token ID.
     * `to` - Target address that will receive the token.
     * `tokenId` - Token ID to be transferred.
     * `_data` - Optional data to send along with the call.
     *
     * Returns whether the call correctly returned the expected magic value.
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    // =============================================================
    //                        MINT OPERATIONS
    // =============================================================

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _mint(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // `balance` and `numberMinted` have a maximum limit of 2**64.
        // `tokenId` has a maximum limit of 2**256.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            uint256 toMasked;
            uint256 end = startTokenId + quantity;

            // Use assembly to loop and emit the `Transfer` event for gas savings.
            // The duplicated `log4` removes an extra check and reduces stack juggling.
            // The assembly, together with the surrounding Solidity code, have been
            // delicately arranged to nudge the compiler into producing optimized opcodes.
            assembly {
                // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                toMasked := and(to, _BITMASK_ADDRESS)
                // Emit the `Transfer` event.
                log4(
                    0, // Start of data (0, since no data).
                    0, // End of data (0, since no data).
                    _TRANSFER_EVENT_SIGNATURE, // Signature.
                    0, // `address(0)`.
                    toMasked, // `to`.
                    startTokenId // `tokenId`.
                )

                // The `iszero(eq(,))` check ensures that large values of `quantity`
                // that overflows uint256 will make the loop run out of gas.
                // The compiler will optimize the `iszero` away for performance.
                for {
                    let tokenId := add(startTokenId, 1)
                } iszero(eq(tokenId, end)) {
                    tokenId := add(tokenId, 1)
                } {
                    // Emit the `Transfer` event. Similar to above.
                    log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
                }
            }
            if (toMasked == 0) revert MintToZeroAddress();

            _currentIndex = end;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
    function _mintERC2309(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();
        if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

            _currentIndex = startTokenId + quantity;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, '');
    }

    // =============================================================
    //                        BURN OPERATIONS
    // =============================================================

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        address from = address(uint160(prevOwnershipPacked));

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        if (approvalCheck) {
            // The nested ifs save around 20+ gas over a compound boolean condition.
            if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
        unchecked {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                from,
                (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    // =============================================================
    //                     EXTRA DATA OPERATIONS
    // =============================================================

    /**
     * @dev Directly sets the extra data for the ownership data `index`.
     */
    function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
        uint256 packed = _packedOwnerships[index];
        if (packed == 0) revert OwnershipNotInitializedForExtraData();
        uint256 extraDataCasted;
        // Cast `extraData` with assembly to avoid redundant masking.
        assembly {
            extraDataCasted := extraData
        }
        packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
        _packedOwnerships[index] = packed;
    }

    /**
     * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _extraData(
        address from,
        address to,
        uint24 previousExtraData
    ) internal view virtual returns (uint24) {}

    /**
     * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
    function _nextExtraData(
        address from,
        address to,
        uint256 prevOwnershipPacked
    ) private view returns (uint256) {
        uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
        return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
    }

    // =============================================================
    //                       OTHER OPERATIONS
    // =============================================================

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a uint256 to its ASCII string decimal representation.
     */
    function _toString(uint256 value) internal pure virtual returns (string memory str) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
            let m := add(mload(0x40), 0xa0)
            // Update the free memory pointer to allocate.
            mstore(0x40, m)
            // Assign the `str` to the end.
            str := sub(m, 0x20)
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                str := sub(str, 1)
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                // prettier-ignore
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }
}

// File: erc721a/contracts/interfaces/ERC721ABurnable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;



/**
 * @title ERC721ABurnable.
 *
 * @dev ERC721A token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721ABurnable is ERC721A, IERC721ABurnable {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual override {
        _burn(tokenId, true);
    }
}

// File: erc721a/contracts/interfaces/ERC721AQueryable.sol


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;



/**
 * @title ERC721AQueryable.
 *
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *
     * - `addr = address(0)`
     * - `startTimestamp = 0`
     * - `burned = false`
     * - `extraData = 0`
     *
     * If the `tokenId` is burned:
     *
     * - `addr = <Address of owner before token was burned>`
     * - `startTimestamp = <Timestamp when token was burned>`
     * - `burned = true`
     * - `extraData = <Extra data when token was burned>`
     *
     * Otherwise:
     *
     * - `addr = <Address of owner>`
     * - `startTimestamp = <Timestamp of start of ownership>`
     * - `burned = false`
     * - `extraData = <Extra data at start of ownership>`
     */
    function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory) {
        TokenOwnership memory ownership;
        if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
            return ownership;
        }
        ownership = _ownershipAt(tokenId);
        if (ownership.burned) {
            return ownership;
        }
        return _ownershipOf(tokenId);
    }

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] calldata tokenIds)
        external
        view
        virtual
        override
        returns (TokenOwnership[] memory)
    {
        unchecked {
            uint256 tokenIdsLength = tokenIds.length;
            TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
            for (uint256 i; i != tokenIdsLength; ++i) {
                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
            }
            return ownerships;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view virtual override returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            uint256 tokenIdsIdx;
            uint256 stopLimit = _nextTokenId();
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            // Set `stop = min(stop, stopLimit)`.
            if (stop > stopLimit) {
                stop = stopLimit;
            }
            uint256 tokenIdsMaxLength = balanceOf(owner);
            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
            // to cater for cases where `balanceOf(owner)` is too big.
            if (start < stop) {
                uint256 rangeLength = stop - start;
                if (rangeLength < tokenIdsMaxLength) {
                    tokenIdsMaxLength = rangeLength;
                }
            } else {
                tokenIdsMaxLength = 0;
            }
            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
            if (tokenIdsMaxLength == 0) {
                return tokenIds;
            }
            // We need to call `explicitOwnershipOf(start)`,
            // because the slot at `start` may not be initialized.
            TokenOwnership memory ownership = explicitOwnershipOf(start);
            address currOwnershipAddr;
            // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
            // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
            if (!ownership.burned) {
                currOwnershipAddr = ownership.addr;
            }
            for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            // Downsize the array to fit.
            assembly {
                mstore(tokenIds, tokenIdsIdx)
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner) external view virtual override returns (uint256[] memory) {
        unchecked {
            uint256 tokenIdsIdx;
            address currOwnershipAddr;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            TokenOwnership memory ownership;
            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                ownership = _ownershipAt(i);
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }
}

// File: tubbystation/tubby.sol

//SPDX-License-Identifier: MIT






pragma solidity ^0.8.17;

contract TubbyStation is ERC721A, ERC721AQueryable, ERC721ABurnable, Ownable {

    error TooMany(string err);
    error NotEnough(string err);
    error NoDice(string err);

    string public uri = '';
    bytes32 private root = '';
    bool public saleOn = false;
    
    mapping(address => bool) public freeMinted;

    constructor() ERC721A("TubbyStation", "TS") {
        _initializeOwner(msg.sender);
        _mint(msg.sender,12);
    }

    function _startTokenId() internal view virtual override returns (uint256) {
        return 1;
    }

    function configure(bytes32 newRoot, string calldata newUri) public onlyOwner {
        root = newRoot;
        uri = newUri;
    }

    function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
        return uri;
    }
    
    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    function flipSaleState() public onlyOwner {
        saleOn = !saleOn;
    }

    function checkList(bytes32[] calldata proof) internal view returns (bool){
        return MerkleProofLib.verifyCalldata(proof, root, keccak256(abi.encodePacked(bytes20(msg.sender))));
    }

    function mint(uint256 amount) public payable{
        if(!saleOn){revert NoDice("Sale Not On");}
        if(msg.value < 10000000000000000*amount){revert NotEnough("Need Fee");}
        if(balanceOf(msg.sender) + amount > 8){revert TooMany("8/wallet max");}
        if(totalSupply()+amount > 365){revert TooMany("Exceeds Supply");}
        _mint(msg.sender,amount);
    }

    function freeMint(bytes32[] calldata proof) public {
        if(!saleOn){revert NoDice("Sale Not On");}
        if(!checkList(proof)){revert NoDice("Not on List");}
        if(totalSupply()+2 > 365){revert TooMany("Exceeds Supply");}
        if(freeMinted[msg.sender]){revert NoDice("Already Minted");}
        _mint(msg.sender,2);
        freeMinted[msg.sender] = true;        
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[{"internalType":"string","name":"err","type":"string"}],"name":"NoDice","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[{"internalType":"string","name":"err","type":"string"}],"name":"NotEnough","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","type":"error"},{"inputs":[{"internalType":"string","name":"err","type":"string"}],"name":"TooMany","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","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":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"bytes32","name":"newRoot","type":"bytes32"},{"internalType":"string","name":"newUri","type":"string"}],"name":"configure","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"explicitOwnershipOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"explicitOwnershipsOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"},{"internalType":"uint24","name":"extraData","type":"uint24"}],"internalType":"struct IERC721A.TokenOwnership[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"freeMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","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":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","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":"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":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"saleOn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

87744:2051:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47550:639;;;;;;;;;;-1:-1:-1;47550:639:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;47550:639:0;;;;;;;;48452:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54943:218::-;;;;;;;;;;-1:-1:-1;54943:218:0;;;;;:::i;:::-;;:::i;:::-;;;1814:42:1;1802:55;;;1784:74;;1772:2;1757:18;54943:218:0;1638:226:1;54376:408:0;;;;;;:::i;:::-;;:::i;:::-;;44203:323;;;;;;;;;;-1:-1:-1;88302:1:0;44477:12;44264:7;44461:13;:28;:46;;44203:323;;;2475:25:1;;;2463:2;2448:18;44203:323:0;2329:177:1;58582:2825:0;;;;;;:::i;:::-;;:::i;22529:630::-;;;:::i;88733:77::-;;;;;;;;;;;;;:::i;88029:42::-;;;;;;;;;;-1:-1:-1;88029:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;88585:140;;;;;;;;;;;;;:::i;61503:193::-;;;;;;:::i;:::-;;:::i;81085:94::-;;;;;;;;;;-1:-1:-1;81085:94:0;;;;;:::i;:::-;;:::i;23244:466::-;;;:::i;82854:528::-;;;;;;;;;;-1:-1:-1;82854:528:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49845:152::-;;;;;;;;;;-1:-1:-1;49845:152:0;;;;;:::i;:::-;;:::i;45387:233::-;;;;;;;;;;-1:-1:-1;45387:233:0;;;;;:::i;:::-;;:::i;22264:102::-;;;:::i;87990:26::-;;;;;;;;;;-1:-1:-1;87990:26:0;;;;;;;;86730:900;;;;;;;;;;-1:-1:-1;86730:900:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;89401:391::-;;;;;;;;;;-1:-1:-1;89401:391:0;;;;;:::i;:::-;;:::i;24969:196::-;;;;;;;;;;-1:-1:-1;25126:20:0;25120:27;24969:196;;48628:104;;;;;;;;;;;;;:::i;83770:2513::-;;;;;;;;;;-1:-1:-1;83770:2513:0;;;;;:::i;:::-;;:::i;89017:376::-;;;;;;:::i;:::-;;:::i;55501:234::-;;;;;;;;;;-1:-1:-1;55501:234:0;;;;;:::i;:::-;;:::i;88319:133::-;;;;;;;;;;-1:-1:-1;88319:133:0;;;;;:::i;:::-;;:::i;62294:407::-;;;;;;:::i;:::-;;:::i;82267:428::-;;;;;;;;;;-1:-1:-1;82267:428:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;48838:318::-;;;;;;;;;;-1:-1:-1;48838:318:0;;;;;:::i;:::-;;:::i;55892:164::-;;;;;;;;;;-1:-1:-1;55892:164:0;;;;;:::i;:::-;56013:25;;;;55989:4;56013:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55892:164;87929:22;;;;;;;;;;;;;:::i;23901:724::-;;;;;;:::i;:::-;;:::i;21838:358::-;;;;;;:::i;:::-;;:::i;25271:449::-;;;;;;;;;;-1:-1:-1;25271:449:0;;;;;:::i;:::-;25550:19;25544:4;25537:33;;;25394:14;25584:26;;;;25696:4;25680:21;;25674:28;;25271:449;47550:639;47635:4;47959:25;;;;;;:102;;-1:-1:-1;48036:25:0;;;;;47959:102;:179;;;-1:-1:-1;48113:25:0;;;;;47959:179;47939:199;47550:639;-1:-1:-1;;47550:639:0:o;48452:100::-;48506:13;48539:5;48532:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48452:100;:::o;54943:218::-;55019:7;55044:16;55052:7;55044;:16::i;:::-;55039:64;;55069:34;;;;;;;;;;;;;;55039:64;-1:-1:-1;55123:24:0;;;;:15;:24;;;;;:30;;;;54943:218::o;54376:408::-;54465:13;54481:16;54489:7;54481;:16::i;:::-;54465:32;-1:-1:-1;78709:10:0;54514:28;;;;54510:175;;54562:44;54579:5;78709:10;55892:164;:::i;54562:44::-;54557:128;;54634:35;;;;;;;;;;;;;;54557:128;54697:24;;;;:15;:24;;;;;;:35;;;;;;;;;;;;;;54748:28;;54697:24;;54748:28;;;;;;;54454:330;54376:408;;:::o;58582:2825::-;58724:27;58754;58773:7;58754:18;:27::i;:::-;58724:57;;58839:4;58798:45;;58814:19;58798:45;;;58794:86;;58852:28;;;;;;;;;;;;;;58794:86;58894:27;57690:24;;;:15;:24;;;;;57918:26;;59085:68;57918:26;59127:4;78709:10;59133:19;57019:16;57164:32;;;57008:28;;57293:20;;57315:30;;57290:56;;56705:659;59085:68;59080:180;;59173:43;59190:4;78709:10;55892:164;:::i;59173:43::-;59168:92;;59225:35;;;;;;;;;;;;;;59168:92;59277:16;;;59273:52;;59302:23;;;;;;;;;;;;;;59273:52;59474:15;59471:160;;;59614:1;59593:19;59586:30;59471:160;60011:24;;;;;;;;:18;:24;;;;;;60009:26;;;;;;60080:22;;;;;;;;;60078:24;;-1:-1:-1;60078:24:0;;;53234:11;53209:23;53205:41;53192:63;40602:8;53192:63;60373:26;;;;:17;:26;;;;;:175;;;;40602:8;60668:47;;:52;;60664:627;;60773:1;60763:11;;60741:19;60896:30;;;:17;:30;;;;;;:35;;60892:384;;61034:13;;61019:11;:28;61015:242;;61181:30;;;;:17;:30;;;;;:52;;;61015:242;60722:569;60664:627;61338:7;61334:2;61319:27;;61328:4;61319:27;;;;;;;;;;;;61357:42;58713:2694;;;58582:2825;;;:::o;22529:630::-;22624:15;21454:9;22642:46;;:15;:46;22624:64;;22860:19;22854:4;22847:33;22911:8;22905:4;22898:22;22968:7;22961:4;22955;22945:21;22938:38;23117:8;23070:45;23067:1;23064;23059:67;22760:381;22529:630::o;88733:77::-;26117:13;:11;:13::i;:::-;88796:6:::1;::::0;;88786:16;;::::1;88796:6;::::0;;::::1;88795:7;88786:16;::::0;;88733:77::o;88585:140::-;26117:13;:11;:13::i;:::-;88680:37:::1;::::0;88648:21:::1;::::0;88688:10:::1;::::0;88680:37;::::1;;;::::0;88648:21;;88633:12:::1;88680:37:::0;88633:12;88680:37;88648:21;88688:10;88680:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;88622:103;88585:140::o:0;61503:193::-;61649:39;61666:4;61672:2;61676:7;61649:39;;;;;;;;;;;;:16;:39::i;:::-;61503:193;;;:::o;81085:94::-;81151:20;81157:7;81166:4;81151:5;:20::i;:::-;81085:94;:::o;23244:466::-;23450:19;23444:4;23437:33;23497:8;23491:4;23484:22;23550:1;23543:4;23537;23527:21;23520:32;23683:8;23637:44;23634:1;23631;23626:66;23244:466::o;82854:528::-;82998:23;83089:8;83064:22;83089:8;83156:36;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83156:36:0;;;;;;;;;;;;;;;83119:73;;83212:9;83207:125;83228:14;83223:1;:19;83207:125;;83284:32;83304:8;;83313:1;83304:11;;;;;;;:::i;:::-;;;;;;;83284:19;:32::i;:::-;83268:10;83279:1;83268:13;;;;;;;;:::i;:::-;;;;;;;;;;:48;83244:3;;83207:125;;;-1:-1:-1;83353:10:0;82854:528;-1:-1:-1;;;;82854:528:0:o;49845:152::-;49917:7;49960:27;49979:7;49960:18;:27::i;45387:233::-;45459:7;45483:19;;;45479:60;;45511:28;;;;;;;;;;;;;;45479:60;-1:-1:-1;45557:25:0;;;;;;:18;:25;;;;;;39546:13;45557:55;;45387:233::o;22264:102::-;26117:13;:11;:13::i;:::-;22337:21:::1;22355:1;22337:9;:21::i;:::-;22264:102::o:0;86730:900::-;86808:16;86862:19;86896:25;86936:22;86961:16;86971:5;86961:9;:16::i;:::-;86936:41;;86992:25;87034:14;87020:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87020:29:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86992:57:0;;-1:-1:-1;88302:1:0;87110:472;87159:14;87144:11;:29;87110:472;;87211:15;87224:1;87211:12;:15::i;:::-;87199:27;;87249:9;:16;;;87290:8;87245:73;87340:14;;:28;;;87336:111;;87413:14;;;-1:-1:-1;87336:111:0;87490:5;87469:26;;:17;:26;;;87465:102;;87546:1;87520:8;87529:13;;;;;;87520:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;87465:102;87175:3;;87110:472;;;-1:-1:-1;87603:8:0;;86730:900;-1:-1:-1;;;;;;86730:900:0:o;89401:391::-;89467:6;;;;89463:42;;89482:21;;;;;10136:2:1;89482:21:0;;;10118::1;10175:2;10155:18;;;10148:30;10214:13;10194:18;;;10187:41;10245:18;;89482:21:0;;;;;;;;89463:42;89519:16;89529:5;;89519:9;:16::i;:::-;89515:52;;89544:21;;;;;10476:2:1;89544:21:0;;;10458::1;10515:2;10495:18;;;10488:30;10554:13;10534:18;;;10527:41;10585:18;;89544:21:0;10274:335:1;89515:52:0;88302:1;44477:12;44264:7;44461:13;89598:3;;44461:28;;:46;;89580:15;;89594:1;89580:15;:::i;:::-;:21;89577:60;;;89610:25;;;;;11135:2:1;89610:25:0;;;11117:21:1;11174:2;11154:18;;;11147:30;11213:16;11193:18;;;11186:44;11247:18;;89610:25:0;10933:338:1;89577:60:0;89661:10;89650:22;;;;:10;:22;;;;;;;;89647:60;;;89681:24;;;;;11478:2:1;89681:24:0;;;11460:21:1;11517:2;11497:18;;;11490:30;11556:16;11536:18;;;11529:44;11590:18;;89681:24:0;11276:338:1;89647:60:0;89717:19;89723:10;89734:1;89717:5;:19::i;:::-;-1:-1:-1;;89758:10:0;89747:22;;;;:10;:22;;;;;:29;;;;89772:4;89747:29;;;89401:391::o;48628:104::-;48684:13;48717:7;48710:14;;;;;:::i;83770:2513::-;83913:16;83980:4;83971:5;:13;83967:45;;83993:19;;;;;;;;;;;;;;83967:45;84027:19;84061:17;84081:14;43945:7;43972:13;;43890:103;84081:14;84061:34;-1:-1:-1;88302:1:0;84173:5;:23;84169:87;;;88302:1;84217:23;;84169:87;84332:9;84325:4;:16;84321:73;;;84369:9;84362:16;;84321:73;84408:25;84436:16;84446:5;84436:9;:16::i;:::-;84408:44;;84630:4;84622:5;:12;84618:278;;;84677:12;;;84712:31;;;84708:111;;;84788:11;84768:31;;84708:111;84636:198;84618:278;;;-1:-1:-1;84879:1:0;84618:278;84910:25;84952:17;84938:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;84938:32:0;;84910:60;;84989:17;85010:1;84989:22;84985:78;;85039:8;-1:-1:-1;85032:15:0;;-1:-1:-1;;;85032:15:0;84985:78;85207:31;85241:26;85261:5;85241:19;:26::i;:::-;85207:60;;85282:25;85527:9;:16;;;85522:92;;-1:-1:-1;85584:14:0;;85522:92;85645:5;85628:478;85657:4;85652:1;:9;;:45;;;;;85680:17;85665:11;:32;;85652:45;85628:478;;;85735:15;85748:1;85735:12;:15::i;:::-;85723:27;;85773:9;:16;;;85814:8;85769:73;85864:14;;:28;;;85860:111;;85937:14;;;-1:-1:-1;85860:111:0;86014:5;85993:26;;:17;:26;;;85989:102;;86070:1;86044:8;86053:13;;;;;;86044:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;85989:102;85699:3;;85628:478;;;-1:-1:-1;;;86191:29:0;;;-1:-1:-1;86198:8:0;;-1:-1:-1;;83770:2513:0;;;;;;:::o;89017:376::-;89076:6;;;;89072:42;;89091:21;;;;;10136:2:1;89091:21:0;;;10118::1;10175:2;10155:18;;;10148:30;10214:13;10194:18;;;10187:41;10245:18;;89091:21:0;9934:335:1;89072:42:0;89139:24;89157:6;89139:17;:24;:::i;:::-;89127:9;:36;89124:71;;;89172:21;;;;;11994:2:1;89172:21:0;;;11976::1;12033:1;12013:18;;;12006:29;12071:10;12051:18;;;12044:38;12099:18;;89172:21:0;11792:331:1;89124:71:0;89241:1;89232:6;89208:21;89218:10;89208:9;:21::i;:::-;:30;;;;:::i;:::-;:34;89205:71;;;89251:23;;;;;12330:2:1;89251:23:0;;;12312:21:1;12369:2;12349:18;;;12342:30;12408:14;12388:18;;;12381:42;12440:18;;89251:23:0;12128:336:1;89205:71:0;88302:1;44477:12;44264:7;44461:13;89312:3;;89303:6;;44461:28;:46;;89289:20;;;;:::i;:::-;:26;89286:65;;;89324:25;;;;;11135:2:1;89324:25:0;;;11117:21:1;11174:2;11154:18;;;11147:30;11213:16;11193:18;;;11186:44;11247:18;;89324:25:0;10933:338:1;89286:65:0;89361:24;89367:10;89378:6;89361:5;:24::i;55501:234::-;78709:10;55596:39;;;;:18;:39;;;;;;;;;:49;;;;;;;;;;;;:60;;;;;;;;;;;;;55672:55;;586:41:1;;;55596:49:0;;78709:10;55672:55;;559:18:1;55672:55:0;;;;;;;55501:234;;:::o;88319:133::-;26117:13;:11;:13::i;:::-;88407:4:::1;:14:::0;;;88432:3:::1;:12;88438:6:::0;;88432:3;:12:::1;:::i;:::-;;88319:133:::0;;;:::o;62294:407::-;62469:31;62482:4;62488:2;62492:7;62469:12;:31::i;:::-;62515:14;;;;:19;62511:183;;62554:56;62585:4;62591:2;62595:7;62604:5;62554:30;:56::i;:::-;62549:145;;62638:40;;;;;;;;;;;;;;82267:428;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88302:1:0;82431:7;:25;:54;;;-1:-1:-1;43945:7:0;43972:13;82460:7;:25;;82431:54;82427:103;;;82509:9;82267:428;-1:-1:-1;;82267:428:0:o;82427:103::-;82552:21;82565:7;82552:12;:21::i;:::-;82540:33;;82588:9;:16;;;82584:65;;;82628:9;82267:428;-1:-1:-1;;82267:428:0:o;82584:65::-;82666:21;82679:7;82666:12;:21::i;48838:318::-;48911:13;48942:16;48950:7;48942;:16::i;:::-;48937:59;;48967:29;;;;;;;;;;;;;;48937:59;49009:21;49033:10;:8;:10::i;:::-;49009:34;;49067:7;49061:21;49086:1;49061:26;:87;;;;;;;;;;;;;;;;;49114:7;49123:18;49133:7;49123:9;:18::i;:::-;49097:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49054:94;48838:318;-1:-1:-1;;;48838:318:0:o;87929:22::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23901:724::-;26117:13;:11;:13::i;:::-;24139:19:::1;24133:4;24126:33;24186:12;24180:4;24173:26;24249:4;24243;24233:21;24357:12;24351:19;24338:11;24335:36;24332:160;;;24404:10;24398:4;24391:24;24472:4;24466;24459:18;24332:160;24571:1;24550:23:::0;;24594::::1;24604:12:::0;24594:9:::1;:23::i;21838:358::-:0;26117:13;:11;:13::i;:::-;22013:8:::1;22009:2;22005:17;21995:153;;22056:10;22050:4;22043:24;22128:4;22122;22115:18;21995:153;22169:19;22179:8;22169:9;:19::i;56314:282::-:0;56379:4;56435:7;88302:1;56416:26;;:66;;;;;56469:13;;56459:7;:23;56416:66;:153;;;;-1:-1:-1;;56520:26:0;;;;:17;:26;;;;;;40322:8;56520:44;:49;;56314:282::o;51000:1275::-;51067:7;51102;;88302:1;51151:23;51147:1061;;51204:13;;51197:4;:20;51193:1015;;;51242:14;51259:23;;;:17;:23;;;;;;;40322:8;51348:24;;:29;;51344:845;;52013:113;52020:6;52030:1;52020:11;52013:113;;-1:-1:-1;52091:6:0;;52073:25;;;;:17;:25;;;;;;52013:113;;51344:845;51219:989;51193:1015;52236:31;;;;;;;;;;;;;;20750:373;20966:20;20960:27;20950:8;20947:41;20937:168;;21022:10;21016:4;21009:24;21085:4;21079;21072:18;73151:3081;73231:27;73261;73280:7;73261:18;:27::i;:::-;73231:57;-1:-1:-1;73231:57:0;73301:12;;73423:35;73450:7;57579:27;57690:24;;;:15;:24;;;;;57918:26;;57690:24;;57477:485;73423:35;73366:92;;;;73475:13;73471:316;;;73596:68;73621:15;73638:4;78709:10;73644:19;78622:105;73596:68;73591:184;;73688:43;73705:4;78709:10;55892:164;:::i;73688:43::-;73683:92;;73740:35;;;;;;;;;;;;;;73683:92;73943:15;73940:160;;;74083:1;74062:19;74055:30;73940:160;74702:24;;;;;;;:18;:24;;;;;:60;;74730:32;74702:60;;;53234:11;53209:23;53205:41;53192:63;75090:43;53192:63;75000:26;;;;:17;:26;;;;;:205;;;;40602:8;75325:47;;:52;;75321:627;;75430:1;75420:11;;75398:19;75553:30;;;:17;:30;;;;;;:35;;75549:384;;75691:13;;75676:11;:28;75672:242;;75838:30;;;;:17;:30;;;;;:52;;;75672:242;75379:569;75321:627;75976:35;;76003:7;;75999:1;;75976:35;;;;;;75999:1;;75976:35;-1:-1:-1;;76199:12:0;:14;;;;;;-1:-1:-1;;;;73151:3081:0:o;20183:506::-;20333:20;20566:16;;20420:26;;;;;;;20526:38;20523:1;;20515:78;20644:27;20183:506::o;50448:161::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50576:24:0;;;;:17;:24;;;;;;50557:44;;-1:-1:-1;;;;;;;;52484:41:0;;;;;40205:3;52570:33;;;52536:68;;-1:-1:-1;;;52536:68:0;40322:8;52634:24;;:29;;-1:-1:-1;;;52615:48:0;;;;40726:3;52703:28;;;;-1:-1:-1;;;52674:58:0;-1:-1:-1;52374:366:0;88818:191;88946:4;;88962:37;;15360:66:1;88987:10:0;88979:19;;15348:79:1;88962:37:0;;;15336:92:1;88886:4:0;;88909:92;;88939:5;;;;15444:12:1;;88962:37:0;;;;;;;;;;;;88952:48;;;;;;88909:29;:92::i;65963:2966::-;66036:20;66059:13;;;66087;;;66083:44;;66109:18;;;;;;;;;;;;;;66083:44;66615:22;;;;;;;:18;:22;;;;39684:2;66615:22;;;:71;;66653:32;66641:45;;66615:71;;;66929:31;;;:17;:31;;;;;-1:-1:-1;53665:15:0;;53639:24;53635:46;53234:11;53209:23;53205:41;53202:52;53192:63;;66929:173;;67164:23;;;;66929:31;;66615:22;;67929:25;66615:22;;67782:335;68443:1;68429:12;68425:20;68383:346;68484:3;68475:7;68472:16;68383:346;;68702:7;68692:8;68689:1;68662:25;68659:1;68656;68651:59;68537:1;68524:15;68383:346;;;68387:77;68762:8;68774:1;68762:13;68758:45;;68784:19;;;;;;;;;;;;;;68758:45;68820:13;:19;-1:-1:-1;61503:193:0;;;:::o;64785:716::-;64969:88;;;;;64948:4;;64969:45;;;;;;:88;;78709:10;;65036:4;;65042:7;;65051:5;;64969:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64969:88:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;64965:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65252:6;:13;65269:1;65252:18;65248:235;;65298:40;;;;;;;;;;;;;;65248:235;65441:6;65435:13;65426:6;65422:2;65418:15;65411:38;64965:529;65128:64;;65138:54;65128:64;;-1:-1:-1;64785:716:0;;;;;;:::o;50186:166::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50297:47:0;50316:27;50335:7;50316:18;:27::i;:::-;-1:-1:-1;;;;;;;;52484:41:0;;;;;40205:3;52570:33;;;52536:68;;-1:-1:-1;;;52536:68:0;40322:8;52634:24;;:29;;-1:-1:-1;;;52615:48:0;;;;40726:3;52703:28;;;;-1:-1:-1;;;52674:58:0;-1:-1:-1;52374:366:0;88460:113;88529:13;88562:3;88555:10;;;;;:::i;78829:1745::-;78894:17;79328:4;79321;79315:11;79311:22;79420:1;79414:4;79407:15;79495:4;79492:1;79488:12;79481:19;;;79577:1;79572:3;79565:14;79681:3;79920:5;79902:428;79968:1;79963:3;79959:11;79952:18;;80139:2;80133:4;80129:13;80125:2;80121:22;80116:3;80108:36;80233:2;80223:13;;80290:25;79902:428;80290:25;-1:-1:-1;80360:13:0;;;80475:14;;;;80537:19;;;80475:14;78829:1745;-1:-1:-1;78829:1745:0:o;2459:1436::-;2587:12;2688;2685:1153;;;2830:12;2827:1;2823:20;2809:12;2805:39;2958:12;3058:765;3254:20;;3245:30;;;3242:1;3238:38;3472:21;;;3535:4;3522:18;;;3515:48;3692:4;3686;3676:21;;3729:17;3778:15;;;3058:765;3768:36;3062:2;;2685:1153;-1:-1:-1;3863:14:0;;2459:1436;-1:-1:-1;;2459:1436:0:o;14:177:1:-;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:250::-;723:1;733:113;747:6;744:1;741:13;733:113;;;823:11;;;817:18;804:11;;;797:39;769:2;762:10;733:113;;;-1:-1:-1;;880:1:1;862:16;;855:27;638:250::o;893:330::-;935:3;973:5;967:12;1000:6;995:3;988:19;1016:76;1085:6;1078:4;1073:3;1069:14;1062:4;1055:5;1051:16;1016:76;:::i;:::-;1137:2;1125:15;1142:66;1121:88;1112:98;;;;1212:4;1108:109;;893:330;-1:-1:-1;;893:330:1:o;1228:220::-;1377:2;1366:9;1359:21;1340:4;1397:45;1438:2;1427:9;1423:18;1415:6;1397:45;:::i;1453:180::-;1512:6;1565:2;1553:9;1544:7;1540:23;1536:32;1533:52;;;1581:1;1578;1571:12;1533:52;-1:-1:-1;1604:23:1;;1453:180;-1:-1:-1;1453:180:1:o;1869:196::-;1937:20;;1997:42;1986:54;;1976:65;;1966:93;;2055:1;2052;2045:12;1966:93;1869:196;;;:::o;2070:254::-;2138:6;2146;2199:2;2187:9;2178:7;2174:23;2170:32;2167:52;;;2215:1;2212;2205:12;2167:52;2238:29;2257:9;2238:29;:::i;:::-;2228:39;2314:2;2299:18;;;;2286:32;;-1:-1:-1;;;2070:254:1:o;2511:328::-;2588:6;2596;2604;2657:2;2645:9;2636:7;2632:23;2628:32;2625:52;;;2673:1;2670;2663:12;2625:52;2696:29;2715:9;2696:29;:::i;:::-;2686:39;;2744:38;2778:2;2767:9;2763:18;2744:38;:::i;:::-;2734:48;;2829:2;2818:9;2814:18;2801:32;2791:42;;2511:328;;;;;:::o;2844:186::-;2903:6;2956:2;2944:9;2935:7;2931:23;2927:32;2924:52;;;2972:1;2969;2962:12;2924:52;2995:29;3014:9;2995:29;:::i;3035:367::-;3098:8;3108:6;3162:3;3155:4;3147:6;3143:17;3139:27;3129:55;;3180:1;3177;3170:12;3129:55;-1:-1:-1;3203:20:1;;3246:18;3235:30;;3232:50;;;3278:1;3275;3268:12;3232:50;3315:4;3307:6;3303:17;3291:29;;3375:3;3368:4;3358:6;3355:1;3351:14;3343:6;3339:27;3335:38;3332:47;3329:67;;;3392:1;3389;3382:12;3329:67;3035:367;;;;;:::o;3407:437::-;3493:6;3501;3554:2;3542:9;3533:7;3529:23;3525:32;3522:52;;;3570:1;3567;3560:12;3522:52;3610:9;3597:23;3643:18;3635:6;3632:30;3629:50;;;3675:1;3672;3665:12;3629:50;3714:70;3776:7;3767:6;3756:9;3752:22;3714:70;:::i;:::-;3803:8;;3688:96;;-1:-1:-1;3407:437:1;-1:-1:-1;;;;3407:437:1:o;4226:722::-;4459:2;4511:21;;;4581:13;;4484:18;;;4603:22;;;4430:4;;4459:2;4682:15;;;;4656:2;4641:18;;;4430:4;4725:197;4739:6;4736:1;4733:13;4725:197;;;4788:52;4836:3;4827:6;4821:13;3947:42;3939:5;3933:12;3929:61;3924:3;3917:74;4052:18;4044:4;4037:5;4033:16;4027:23;4023:48;4016:4;4011:3;4007:14;4000:72;4135:4;4128:5;4124:16;4118:23;4111:31;4104:39;4097:4;4092:3;4088:14;4081:63;4205:8;4197:4;4190:5;4186:16;4180:23;4176:38;4169:4;4164:3;4160:14;4153:62;;;3849:372;4788:52;4897:15;;;;4869:4;4860:14;;;;;4761:1;4754:9;4725:197;;4953:632;5124:2;5176:21;;;5246:13;;5149:18;;;5268:22;;;5095:4;;5124:2;5347:15;;;;5321:2;5306:18;;;5095:4;5390:169;5404:6;5401:1;5398:13;5390:169;;;5465:13;;5453:26;;5534:15;;;;5499:12;;;;5426:1;5419:9;5390:169;;6032:322;6109:6;6117;6125;6178:2;6166:9;6157:7;6153:23;6149:32;6146:52;;;6194:1;6191;6184:12;6146:52;6217:29;6236:9;6217:29;:::i;:::-;6207:39;6293:2;6278:18;;6265:32;;-1:-1:-1;6344:2:1;6329:18;;;6316:32;;6032:322;-1:-1:-1;;;6032:322:1:o;6359:347::-;6424:6;6432;6485:2;6473:9;6464:7;6460:23;6456:32;6453:52;;;6501:1;6498;6491:12;6453:52;6524:29;6543:9;6524:29;:::i;:::-;6514:39;;6603:2;6592:9;6588:18;6575:32;6650:5;6643:13;6636:21;6629:5;6626:32;6616:60;;6672:1;6669;6662:12;6616:60;6695:5;6685:15;;;6359:347;;;;;:::o;6711:660::-;6791:6;6799;6807;6860:2;6848:9;6839:7;6835:23;6831:32;6828:52;;;6876:1;6873;6866:12;6828:52;6912:9;6899:23;6889:33;;6973:2;6962:9;6958:18;6945:32;6996:18;7037:2;7029:6;7026:14;7023:34;;;7053:1;7050;7043:12;7023:34;7091:6;7080:9;7076:22;7066:32;;7136:7;7129:4;7125:2;7121:13;7117:27;7107:55;;7158:1;7155;7148:12;7107:55;7198:2;7185:16;7224:2;7216:6;7213:14;7210:34;;;7240:1;7237;7230:12;7210:34;7285:7;7280:2;7271:6;7267:2;7263:15;7259:24;7256:37;7253:57;;;7306:1;7303;7296:12;7253:57;7337:2;7333;7329:11;7319:21;;7359:6;7349:16;;;;;6711:660;;;;;:::o;7376:184::-;7428:77;7425:1;7418:88;7525:4;7522:1;7515:15;7549:4;7546:1;7539:15;7565:1197;7660:6;7668;7676;7684;7737:3;7725:9;7716:7;7712:23;7708:33;7705:53;;;7754:1;7751;7744:12;7705:53;7777:29;7796:9;7777:29;:::i;:::-;7767:39;;7825:38;7859:2;7848:9;7844:18;7825:38;:::i;:::-;7815:48;;7910:2;7899:9;7895:18;7882:32;7872:42;;7965:2;7954:9;7950:18;7937:32;7988:18;8029:2;8021:6;8018:14;8015:34;;;8045:1;8042;8035:12;8015:34;8083:6;8072:9;8068:22;8058:32;;8128:7;8121:4;8117:2;8113:13;8109:27;8099:55;;8150:1;8147;8140:12;8099:55;8186:2;8173:16;8208:2;8204;8201:10;8198:36;;;8214:18;;:::i;:::-;8348:2;8342:9;8410:4;8402:13;;8253:66;8398:22;;;8422:2;8394:31;8390:40;8378:53;;;8446:18;;;8466:22;;;8443:46;8440:72;;;8492:18;;:::i;:::-;8532:10;8528:2;8521:22;8567:2;8559:6;8552:18;8607:7;8602:2;8597;8593;8589:11;8585:20;8582:33;8579:53;;;8628:1;8625;8618:12;8579:53;8684:2;8679;8675;8671:11;8666:2;8658:6;8654:15;8641:46;8729:1;8724:2;8719;8711:6;8707:15;8703:24;8696:35;8750:6;8740:16;;;;;;;7565:1197;;;;;;;:::o;8767:266::-;3933:12;;3947:42;3929:61;3917:74;;4044:4;4033:16;;;4027:23;4052:18;4023:48;4007:14;;;4000:72;4135:4;4124:16;;;4118:23;4111:31;4104:39;4088:14;;;4081:63;4197:4;4186:16;;;4180:23;4205:8;4176:38;4160:14;;;4153:62;8963:3;8948:19;;8976:51;3849:372;9038:260;9106:6;9114;9167:2;9155:9;9146:7;9142:23;9138:32;9135:52;;;9183:1;9180;9173:12;9135:52;9206:29;9225:9;9206:29;:::i;:::-;9196:39;;9254:38;9288:2;9277:9;9273:18;9254:38;:::i;:::-;9244:48;;9038:260;;;;;:::o;9303:437::-;9382:1;9378:12;;;;9425;;;9446:61;;9500:4;9492:6;9488:17;9478:27;;9446:61;9553:2;9545:6;9542:14;9522:18;9519:38;9516:218;;9590:77;9587:1;9580:88;9691:4;9688:1;9681:15;9719:4;9716:1;9709:15;9516:218;;9303:437;;;:::o;9745:184::-;9797:77;9794:1;9787:88;9894:4;9891:1;9884:15;9918:4;9915:1;9908:15;10614:184;10666:77;10663:1;10656:88;10763:4;10760:1;10753:15;10787:4;10784:1;10777:15;10803:125;10868:9;;;10889:10;;;10886:36;;;10902:18;;:::i;11619:168::-;11692:9;;;11723;;11740:15;;;11734:22;;11720:37;11710:71;;11761:18;;:::i;12595:545::-;12697:2;12692:3;12689:11;12686:448;;;12733:1;12758:5;12754:2;12747:17;12803:4;12799:2;12789:19;12873:2;12861:10;12857:19;12854:1;12850:27;12844:4;12840:38;12909:4;12897:10;12894:20;12891:47;;;-1:-1:-1;12932:4:1;12891:47;12987:2;12982:3;12978:12;12975:1;12971:20;12965:4;12961:31;12951:41;;13042:82;13060:2;13053:5;13050:13;13042:82;;;13105:17;;;13086:1;13075:13;13042:82;;13376:1325;13500:18;13495:3;13492:27;13489:53;;;13522:18;;:::i;:::-;13551:94;13641:3;13601:38;13633:4;13627:11;13601:38;:::i;:::-;13595:4;13551:94;:::i;:::-;13671:1;13696:2;13691:3;13688:11;13713:1;13708:735;;;;14487:1;14504:3;14501:93;;;-1:-1:-1;14560:19:1;;;14547:33;14501:93;13282:66;13273:1;13269:11;;;13265:84;13261:89;13251:100;13357:1;13353:11;;;13248:117;14607:78;;13681:1014;;13708:735;12542:1;12535:14;;;12579:4;12566:18;;13753:66;13744:76;;;13904:9;13926:229;13940:7;13937:1;13934:14;13926:229;;;14029:19;;;14016:33;14001:49;;14136:4;14121:20;;;;14089:1;14077:14;;;;13956:12;13926:229;;;13930:3;14183;14174:7;14171:16;14168:219;;;14303:66;14297:3;14291;14288:1;14284:11;14280:21;14276:94;14272:99;14259:9;14254:3;14250:19;14237:33;14233:139;14225:6;14218:155;14168:219;;;14430:1;14424:3;14421:1;14417:11;14413:19;14407:4;14400:33;13681:1014;;;13376:1325;;;:::o;14706:496::-;14885:3;14923:6;14917:13;14939:66;14998:6;14993:3;14986:4;14978:6;14974:17;14939:66;:::i;:::-;15068:13;;15027:16;;;;15090:70;15068:13;15027:16;15137:4;15125:17;;15090:70;:::i;:::-;15176:20;;14706:496;-1:-1:-1;;;;14706:496:1:o;15467:512::-;15661:4;15690:42;15771:2;15763:6;15759:15;15748:9;15741:34;15823:2;15815:6;15811:15;15806:2;15795:9;15791:18;15784:43;;15863:6;15858:2;15847:9;15843:18;15836:34;15906:3;15901:2;15890:9;15886:18;15879:31;15927:46;15968:3;15957:9;15953:19;15945:6;15927:46;:::i;:::-;15919:54;15467:512;-1:-1:-1;;;;;;15467:512:1:o;15984:249::-;16053:6;16106:2;16094:9;16085:7;16081:23;16077:32;16074:52;;;16122:1;16119;16112:12;16074:52;16154:9;16148:16;16173:30;16197:5;16173:30;:::i

ipfs://8325ce5f7355fe5640d00e6fa0838a3bb5204e04d4f5c0b13571b0a52b045588