Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

import "./interfaces/IBurnable.sol";
import "./interfaces/IERC721.sol";

/**
 * @dev Minter of CE Token
 *
 *   Huxley Token Id details:
 * - token id until 10110, Issue 1.
 * - token id from 10111 until 20220, Issue 2
 * - token id from 20221 until 30330, Issue 3
 * - token id from 30331 until 38775, Issue 4
 * - token id from 40441 until 49414, Issue 5+6 - If tokenId is even, it is Issue 6. If it is an odd tokenId, it is Issue 5
 *
 */
contract CETokenMinter is Pausable, Ownable {
    using SignatureChecker for address;

    /// @notice Interface to burn HuxleyComics Issues 1, 2 or 3
    IERC721 public immutable huxleyComics;

    /// @notice Interface to burn HuxleyComics Issue 4
    IBurnable public immutable huxleyComics4;

    /// @notice Interface to burn HuxleyComics Issue 5/6
    IBurnable public immutable huxleyComics56;

    /// @notice Interface to mint CE Token
    IERC721 public ceToken;

    /// @notice token id until 10110, Issue 1.
    uint256 immutable lastTokenIssue1 = 10110;

    /// @notice token id from 10111 until 20220, Issue 2
    uint256 immutable lastTokenIssue2 = 20220;

    /// @notice token id from 20221 until 30330, Issue 3
    uint256 immutable lastTokenIssue3 = 30330;

    /// @notice Address of the wallet that signs claim type (free or paid)
    address public signer;

    /**
     * Sets Huxley Comics addresses, CE address and pause the minting
     * @param _huxley123 Huxley Comics address for Issue 1, 2 and 3
     * @param _huxley4 Huxley Comics address for Issue 4
     * @param _huxley56 Huxley Comics address for Issue 5/6
     * @param _ceToken Huxley Collection Edittion address
     */
    constructor(
        address _huxley123,
        address _huxley4,
        address _huxley56,
        address _ceToken
    ) {
        huxleyComics = IERC721(_huxley123);
        huxleyComics4 = IBurnable(_huxley4);
        huxleyComics56 = IBurnable(_huxley56);

        ceToken = IERC721(_ceToken);

        _pause();
    }

    /**
     * Burn 1 or more complete collection. A wallet has a complete collection when it
     * has at least one token from each Issue (1 until 6).
     *
     * It will burn Huxley Comics token and mint 1 Collection Edition (CE) and 1 Access Pass (AP)
     *
     * It needs a signature that will confirm the amount of Free Claim CE. i.e.: Wallet is burning
     * 3 collections. And it will have 2 Free Claim and 1 Paid Claim CE. So, <b>_freeClaimAmount</b>
     * will be equal to 2. And the contract logic will set 2 CE tokens as Free claim and 1 CE Token as Paid Claim.
     *
     * _tokenIds123: If wallet is burning more than one collection, it should follow a specific order.
     * For example, if it is burning 2 collection, it should be:
     * [tokenId_Issue1b, tokenId_Issue2b, tokeId_Issue3b, tokenId_Issue1a, tokenId_Issue2a, tokeId_Issue3a ]
     * [tokenId_Issue4b, tokenId_Issue4a ]
     * [tokenId_Issue5a, tokenId_Issue6a, tokenId_Issue5b, tokenId_Issue6b]
     *
     * So it would burn 1st:
     * [tokenId_Issue1a, tokenId_Issue2a, tokeId_Issue3a, tokenId_Issue4a, tokenId_Issue5a, tokenId_Issue6a]
     *
     * 2nd burn:
     * [tokenId_Issue1b, tokenId_Issue2b, tokeId_Issue3b, tokenId_Issue4b, tokenId_Issue5b, tokenId_Issue6b]
     *
     * It uses tokenId numbers to know if it is from Issue1, Issue2 or Issue 3.
     *
     * It also checks Issue4, Issue 5 and Issue 6 ownership before burning.
     *
     * @param _tokenIds123 Token ids from Issue 1, 2 and 3. The order of the tokens matter
     * @param _tokenIds4 Token ids from Issue 4. The order of the tokens matter
     * @param _tokenIds56 Token ids from Issue 5/6. The order of the token ids matter.
     * @param _freeClaimAmount Amount of free claim
     * @param _signature Signature created by signer to confirm amount of free claim
     */
    function burnCollections(
        uint256[] calldata _tokenIds123,
        uint256[] calldata _tokenIds4,
        uint256[] calldata _tokenIds56,
        uint256 _freeClaimAmount,
        bytes calldata _signature
    ) external whenNotPaused {
        require(
            hasValidSignature(
                _signature,
                _freeClaimAmount,
                _tokenIds123,
                _tokenIds4,
                _tokenIds56
            ),
            "CE: Wrong signature"
        );

        // _tokenIds123.length wasn't added in a local variable because
        // it was getting stack too deep error
        // they all should have the same amount of a complete collection.
        require(
            _tokenIds123.length / 3 == _tokenIds4.length,
            "CEM: Wrong size 4"
        );
        require(
            _tokenIds56.length / 2 == _tokenIds4.length,
            "CEM: Wrong size 56"
        );

        // Loop does the actions below:
        // - Burns 123,
        // - checks Issue 4 ownership
        // - checks 5 and 6 ownership and if it is from 5 and 6
        // - save in memory token ids that will be used in a an event after minting CE token
        // - emits event of collection burned
        uint256 i; // it controls _tokenIds123 index
        uint256 j; // it controls _tokenIds4 index
        uint256 z; // it controls _tokenIds56 index (it is in pair)
        uint256[][] memory tokenIdsBurned = new uint256[][](_tokenIds4.length);

        while (i < _tokenIds123.length) {
            _burnTokens123(
                _tokenIds123[i],
                _tokenIds123[i + 1],
                _tokenIds123[i + 2]
            );

            _checkOwner4Token(_tokenIds4[j]);

            // check 56 ownership and if it is 5 and 6 (it checks if they are even/odd)
            _checkOwner56Tokens(_tokenIds56[z], _tokenIds56[z + 1]);

            uint256[] memory burnedIds = new uint256[](6);
            burnedIds[0] = _tokenIds123[i];
            burnedIds[1] = _tokenIds123[i + 1];
            burnedIds[2] = _tokenIds123[i + 2];
            burnedIds[3] = _tokenIds4[j];
            burnedIds[4] = _tokenIds56[z];
            burnedIds[5] = _tokenIds56[z + 1];

            // it uses j index because it is equal to the amount of CE that will be minted
            tokenIdsBurned[j] = burnedIds;

            unchecked {
                i = i + 3; // issue 123
                ++j; // issue 4
                z = z + 2; // issue 56
            }
        }

        // while loop has already checked tokenids ownership for Issue 4 and Issue 5 and 6
        _burn4(_tokenIds4);
        _burn56(_tokenIds56);

        // mint a certain amount of CE token and the same amount of AP
        _mintCE(_tokenIds4.length, _freeClaimAmount, tokenIdsBurned);
    }

    /**
     * Burns 1 collection set. It is in a different function to save gas since it doesn't loop.
     *
     * Check burnCollections() comments to see how to setup _tokenIds123, _tokenIds4 and _tokenIds56
     * arrays
     *
     * @param _tokenIds123 Token ids from Issue 1, 2 and 3. The order of the tokens matter
     * @param _tokenIds4 Token ids from Issue 4. The order of the tokens matter
     * @param _tokenIds56 Token ids from Issue 5/6. The order of the token ids matter.
     * @param _freeClaimAmount Amount of free claim
     * @param _signature Signature created by signer to confirm amount of free claim
     */
    function burn1Set(
        uint256[] calldata _tokenIds123,
        uint256[] calldata _tokenIds4,
        uint256[] calldata _tokenIds56,
        uint256 _freeClaimAmount,
        bytes calldata _signature
    ) external whenNotPaused {
        require(
            hasValidSignature(
                _signature,
                _freeClaimAmount,
                _tokenIds123,
                _tokenIds4,
                _tokenIds56
            ),
            "CE: Wrong signature"
        );

        // It isn't necessary to check size of _tokenIds1, _tokenIds2 and _tokenIds3
        // because it won't burn more than 1 token from each array.
        // It is different for _tokenIds4 and _tokenIds56 since it is sending the arrays to the burn function.
        require(_tokenIds4.length == 1, "CEM: Wrong size 4");
        require(_tokenIds56.length == 2, "CEM: Wrong size 56");
        require(_freeClaimAmount <= 1, "CEM: Claim Not 0 or 1");

        // transfer tokens to Minter contract and burn them
        _burnTokens123(_tokenIds123[0], _tokenIds123[1], _tokenIds123[2]);

        // check ownership and burn it
        _checkOwner4Token(_tokenIds4[0]);
        _burn4(_tokenIds4);

        _checkOwner56Tokens(_tokenIds56[0], _tokenIds56[1]);
        _burn56(_tokenIds56);

        // since it is just one collection, create the array with size 1
        uint256[][] memory tokenIdsBurned = new uint256[][](1);
        uint256[] memory burnedIds = new uint256[](6);
        burnedIds[0] = _tokenIds123[0];
        burnedIds[1] = _tokenIds123[1];
        burnedIds[2] = _tokenIds123[2];
        burnedIds[3] = _tokenIds4[0];
        burnedIds[4] = _tokenIds56[0];
        burnedIds[5] = _tokenIds56[1];

        tokenIdsBurned[0] = burnedIds;

        // mint 1 CE token. CE Token contract mints also 1 AP token
        _mintCE(1, _freeClaimAmount, tokenIdsBurned);
    }

    /**
     * Burn Tokens from Issue 1, 2 and 3. First it transfer to Minter contract and then burn it.
     * If wallet is not the owner, it will fail and revert.
     * It checks tokenId range to make sure it is from the correct Issue (1, 2 or 3)
     * @param _tokenId1 TokenId from Issue 1
     * @param _tokenId2 TokenId from Issue 2
     * @param _tokenId3 TokenId from Issue 3
     */
    function _burnTokens123(
        uint256 _tokenId1,
        uint256 _tokenId2,
        uint256 _tokenId3
    ) internal {
        require(_tokenId1 <= lastTokenIssue1, "CE: Not Issue 1");

        require(_tokenId2 > lastTokenIssue1, "CE: Not Issue 2");
        require(_tokenId2 <= lastTokenIssue2, "CE: Not Issue 2");

        require(_tokenId3 > lastTokenIssue2, "CE: Not Issue 3");
        require(_tokenId3 <= lastTokenIssue3, "CE: Not Issue 3");

        // 1) transfer token so it can be burned - setApprovalForAll was called before
        // Since it is using msg.sender, we don't need to check ownerOf
        huxleyComics.transferFrom(msg.sender, address(this), _tokenId1);
        huxleyComics.transferFrom(msg.sender, address(this), _tokenId2);
        huxleyComics.transferFrom(msg.sender, address(this), _tokenId3);

        huxleyComics.burn(_tokenId1);
        huxleyComics.burn(_tokenId2);
        huxleyComics.burn(_tokenId3);
    }

    /**
     * Check Issue 4 ownership
     * @param _tokenId4 Token id from Issue 4.
     */
    function _checkOwner4Token(uint256 _tokenId4) internal view {
        require(
            huxleyComics4.ownerOf(_tokenId4) == msg.sender,
            "CE: Not owner 4"
        );
    }

    /**
     * Before burning Issues 56, it needs to check Ownership. It also checks if is from Issue 5 or from Issue 6
     * by verifying if it is even (6) or odd (5)
     * @param _tokenId5 Token Id from Issue 5
     * @param _tokenId6 Token Id from Issue 6
     */
    function _checkOwner56Tokens(
        uint256 _tokenId5,
        uint256 _tokenId6
    ) internal view {
        require(
            huxleyComics56.ownerOf(_tokenId5) == msg.sender,
            "CE: Not owner 56"
        );

        require(
            huxleyComics56.ownerOf(_tokenId6) == msg.sender,
            "CE: Not owner 56"
        );

        require(!isEven(_tokenId5), "CE: Not Issue 5"); // odd tokenId is Issue 5
        require(isEven(_tokenId6), "CE: Not Issue 6"); //  even tokenId is Issue 6
    }

    /**
     * It isn't necessary to check if it is token id from Issue 4 because if it doesn't exist,
     * it fails.
     * @param _tokenIds4 Token id list from Issue 4.
     */
    function _burn4(uint256[] calldata _tokenIds4) internal {
        huxleyComics4.burnBatch(_tokenIds4);
    }

    /**
     * It isn't necessary to check if it is from Issue 5 or 6 because if it isn't
     * it fails when trying to burn or checking ownership. But it is necessary
     * to check if one is Issue 5 and another one is from Issue 6.
     * @param _tokenId56 Token if from Issue 5 and 6.
     */
    function _burn56(uint256[] calldata _tokenId56) internal {
        huxleyComics56.burnBatch(_tokenId56);
    }

    /**
     * Calls CE contract and mint CE Token
     * @param _amountToMint Amount of CE Tokens that will be minted
     * @param _freeClaimAmount Amount of tokens that are free claim
     * @param _tokenIdsBurned Array that has token ids burned. It will be used in an event.
     */
    function _mintCE(
        uint256 _amountToMint,
        uint256 _freeClaimAmount,
        uint256[][] memory _tokenIdsBurned
    ) internal {
        ceToken.mint(
            msg.sender,
            _amountToMint,
            _freeClaimAmount,
            _tokenIdsBurned
        );
    }

    /**
     * If the same tokenId is used to burn another set, it will fail because it was already burned and signature won't
     * be able to be reused.
     *
     * Signature is the hash of tokensIds from Issue 1, 2, 3, 4, 5 and 6 + the freeClaimAmount value + the address of the token
     * ids owner.
     *
     * @param _signature Signature to be verified
     * @param _freeClaimAmount Amount of free claims
     * @param _tokenIds123 List of token ids from Issue 1, 2 and 3
     * @param _tokenIds4 List of token ids from Issue 4
     * @param _tokenIds56 List of token ids from Issue 5 and 6
     */
    function hasValidSignature(
        bytes calldata _signature,
        uint256 _freeClaimAmount,
        uint256[] calldata _tokenIds123,
        uint256[] calldata _tokenIds4,
        uint256[] calldata _tokenIds56
    ) internal view returns (bool) {
        bytes32 result = keccak256(
            abi.encodePacked(
                _tokenIds123,
                _tokenIds4,
                _tokenIds56,
                _freeClaimAmount,
                msg.sender
            )
        );

        bytes32 hash = keccak256(
            abi.encodePacked("\x19Ethereum Signed Message:\n32", result)
        );
        return signer.isValidSignatureNow(hash, _signature);
    }

    /**
     * Set CE Token contract. OnlyOwner can call it
     * @param _addr CE ERC721A Token address
     */
    function setCEToken(address _addr) external onlyOwner {
        ceToken = IERC721(_addr);
    }

    /**
     * Set Signer
     * @param _signer Signer address
     */
    function setSigner(address _signer) external onlyOwner {
        signer = _signer;
    }

    /// @dev check if a number is even - it is used to check if token id is from Issue 5 or Issue 6
    function isEven(uint256 _num) internal pure returns (bool) {
        return _num % 2 == 0;
    }

    /// @dev Pause burn functions
    function pause() external onlyOwner {
        _pause();
    }

    /// @dev Unpause burn functions
    function unpause() external onlyOwner {
        _unpause();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

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

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

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

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

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

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

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

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

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

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

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;

import "erc721a/contracts/interfaces/IERC721A.sol";

/**
 * @notice Interface used by Issue 4 and Issue 56 contracts to expose burnBatch() function
 */
interface IBurnable is IERC721A {
    function burnBatch(uint256[] memory _tokenIds) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;

/**
 * @notice transferFrom() is used by Issue 123 contract to transfer tokens to CETokenMinter contract
 * and then call burn(). mint() is called by CETokenMinter contract to mint CE Token.
 */
interface IERC721 {
    function transferFrom(address from, address to, uint256 tokenId) external;

    function burn(uint256 _tokenId) external;

    function mint(
        address _account,
        uint256 _amountToMint,
        uint256 _freeClaimAmount,
        uint256[][] calldata _tokenIdsBurned
    ) external;
}

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import '../IERC721A.sol';

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_huxley123","type":"address"},{"internalType":"address","name":"_huxley4","type":"address"},{"internalType":"address","name":"_huxley56","type":"address"},{"internalType":"address","name":"_ceToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds123","type":"uint256[]"},{"internalType":"uint256[]","name":"_tokenIds4","type":"uint256[]"},{"internalType":"uint256[]","name":"_tokenIds56","type":"uint256[]"},{"internalType":"uint256","name":"_freeClaimAmount","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"burn1Set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds123","type":"uint256[]"},{"internalType":"uint256[]","name":"_tokenIds4","type":"uint256[]"},{"internalType":"uint256[]","name":"_tokenIds56","type":"uint256[]"},{"internalType":"uint256","name":"_freeClaimAmount","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"burnCollections","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ceToken","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"huxleyComics","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"huxleyComics4","outputs":[{"internalType":"contract IBurnable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"huxleyComics56","outputs":[{"internalType":"contract IBurnable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setCEToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100f55760003560e01c80638456cb5911610097578063b9d69bf411610066578063b9d69bf414610200578063c7c078cc1461021e578063cc7afff81461023c578063f2fde38b1461025a576100f5565b80638456cb591461019e5780638da5cb5b146101a857806391d97eb0146101c6578063a4f40394146101e2576100f5565b80635c975abb116100d35780635c975abb1461013e578063672b81691461015c5780636c19e78314610178578063715018a614610194576100f5565b8063238ac933146100fa5780632e317fc7146101185780633f4ba83a14610134575b600080fd5b610102610276565b60405161010f9190611f14565b60405180910390f35b610132600480360381019061012d919061202a565b61029c565b005b61013c61070f565b005b610146610721565b6040516101539190612141565b60405180910390f35b61017660048036038101906101719190612188565b610737565b005b610192600480360381019061018d9190612188565b610783565b005b61019c6107cf565b005b6101a66107e3565b005b6101b06107f5565b6040516101bd9190611f14565b60405180910390f35b6101e060048036038101906101db919061202a565b61081e565b005b6101ea610c50565b6040516101f79190612214565b60405180910390f35b610208610c74565b6040516102159190612250565b60405180910390f35b610226610c9a565b6040516102339190612214565b60405180910390f35b610244610cbe565b6040516102519190612250565b60405180910390f35b610274600480360381019061026f9190612188565b610ce2565b005b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6102a4610d65565b6102b58282858c8c8c8c8c8c610daf565b6102f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016102eb906122c8565b60405180910390fd5b8686905060038a8a90506103089190612346565b14610348576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161033f906123c3565b60405180910390fd5b8686905060028686905061035c9190612346565b1461039c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103939061242f565b60405180910390fd5b6000806000808a8a905067ffffffffffffffff8111156103bf576103be61244f565b5b6040519080825280602002602001820160405280156103f257816020015b60608152602001906001900390816103dd5790505b5090505b8c8c90508410156106de5761046f8d8d868181106104175761041661247e565b5b905060200201358e8e60018861042d91906124ad565b81811061043d5761043c61247e565b5b905060200201358f8f60028961045391906124ad565b8181106104635761046261247e565b5b90506020020135610eb6565b6104918b8b858181106104855761048461247e565b5b905060200201356113f6565b6104d98989848181106104a7576104a661247e565b5b905060200201358a8a6001866104bd91906124ad565b8181106104cd576104cc61247e565b5b90506020020135611500565b6000600667ffffffffffffffff8111156104f6576104f561244f565b5b6040519080825280602002602001820160405280156105245781602001602082028036833780820191505090505b5090508d8d8681811061053a5761053961247e565b5b90506020020135816000815181106105555761055461247e565b5b6020026020010181815250508d8d60018761057091906124ad565b8181106105805761057f61247e565b5b905060200201358160018151811061059b5761059a61247e565b5b6020026020010181815250508d8d6002876105b691906124ad565b8181106105c6576105c561247e565b5b90506020020135816002815181106105e1576105e061247e565b5b6020026020010181815250508b8b85818110610600576105ff61247e565b5b905060200201358160038151811061061b5761061a61247e565b5b60200260200101818152505089898481811061063a5761063961247e565b5b90506020020135816004815181106106555761065461247e565b5b602002602001018181525050898960018561067091906124ad565b8181106106805761067f61247e565b5b905060200201358160058151811061069b5761069a61247e565b5b602002602001018181525050808285815181106106bb576106ba61247e565b5b6020026020010181905250600385019450836001019350600283019250506103f6565b6106e88b8b6117a3565b6106f28989611834565b6107008b8b905088836118c5565b50505050505050505050505050565b61071761195d565b61071f6119db565b565b60008060009054906101000a900460ff16905090565b61073f61195d565b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b61078b61195d565b80600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6107d761195d565b6107e16000611a3d565b565b6107eb61195d565b6107f3611b02565b565b60008060019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610826610d65565b6108378282858c8c8c8c8c8c610daf565b610876576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161086d906122c8565b60405180910390fd5b600187879050146108bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108b3906123c3565b60405180910390fd5b60028585905014610902576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108f99061242f565b60405180910390fd5b6001831115610946576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161093d9061252d565b60405180910390fd5b61099f8989600081811061095d5761095c61247e565b5b905060200201358a8a60018181106109785761097761247e565b5b905060200201358b8b60028181106109935761099261247e565b5b90506020020135610eb6565b6109c2878760008181106109b6576109b561247e565b5b905060200201356113f6565b6109cc87876117a3565b610a0a858560008181106109e3576109e261247e565b5b90506020020135868660018181106109fe576109fd61247e565b5b90506020020135611500565b610a148585611834565b6000600167ffffffffffffffff811115610a3157610a3061244f565b5b604051908082528060200260200182016040528015610a6457816020015b6060815260200190600190039081610a4f5790505b5090506000600667ffffffffffffffff811115610a8457610a8361244f565b5b604051908082528060200260200182016040528015610ab25781602001602082028036833780820191505090505b5090508a8a6000818110610ac957610ac861247e565b5b9050602002013581600081518110610ae457610ae361247e565b5b6020026020010181815250508a8a6001818110610b0457610b0361247e565b5b9050602002013581600181518110610b1f57610b1e61247e565b5b6020026020010181815250508a8a6002818110610b3f57610b3e61247e565b5b9050602002013581600281518110610b5a57610b5961247e565b5b60200260200101818152505088886000818110610b7a57610b7961247e565b5b9050602002013581600381518110610b9557610b9461247e565b5b60200260200101818152505086866000818110610bb557610bb461247e565b5b9050602002013581600481518110610bd057610bcf61247e565b5b60200260200101818152505086866001818110610bf057610bef61247e565b5b9050602002013581600581518110610c0b57610c0a61247e565b5b6020026020010181815250508082600081518110610c2c57610c2b61247e565b5b6020026020010181905250610c43600186846118c5565b5050505050505050505050565b7f000000000000000000000000c65ef668114a1d0446f960ac4caa8c080efab78681565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b7f00000000000000000000000042fe737749683595e4315b443eadcc9346a994d981565b7f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f81565b610cea61195d565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610d59576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d50906125bf565b60405180910390fd5b610d6281611a3d565b50565b610d6d610721565b15610dad576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610da49061262b565b60405180910390fd5b565b6000808787878787878e33604051602001610dd1989796959493929190612729565b604051602081830303815290604052805190602001209050600081604051602001610dfc9190612804565b604051602081830303815290604052805190602001209050610ea5818d8d8080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611b649092919063ffffffff16565b925050509998505050505050505050565b7f000000000000000000000000000000000000000000000000000000000000277e831115610f19576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f1090612876565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000277e8211610f7b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f72906128e2565b60405180910390fd5b7f0000000000000000000000000000000000000000000000000000000000004efc821115610fde576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fd5906128e2565b60405180910390fd5b7f0000000000000000000000000000000000000000000000000000000000004efc8111611040576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110379061294e565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000767a8111156110a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161109a9061294e565b60405180910390fd5b7f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166323b872dd3330866040518463ffffffff1660e01b81526004016111009392919061297d565b600060405180830381600087803b15801561111a57600080fd5b505af115801561112e573d6000803e3d6000fd5b505050507f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166323b872dd3330856040518463ffffffff1660e01b815260040161118f9392919061297d565b600060405180830381600087803b1580156111a957600080fd5b505af11580156111bd573d6000803e3d6000fd5b505050507f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166323b872dd3330846040518463ffffffff1660e01b815260040161121e9392919061297d565b600060405180830381600087803b15801561123857600080fd5b505af115801561124c573d6000803e3d6000fd5b505050507f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166342966c68846040518263ffffffff1660e01b81526004016112a991906129b4565b600060405180830381600087803b1580156112c357600080fd5b505af11580156112d7573d6000803e3d6000fd5b505050507f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166342966c68836040518263ffffffff1660e01b815260040161133491906129b4565b600060405180830381600087803b15801561134e57600080fd5b505af1158015611362573d6000803e3d6000fd5b505050507f0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f73ffffffffffffffffffffffffffffffffffffffff166342966c68826040518263ffffffff1660e01b81526004016113bf91906129b4565b600060405180830381600087803b1580156113d957600080fd5b505af11580156113ed573d6000803e3d6000fd5b50505050505050565b3373ffffffffffffffffffffffffffffffffffffffff167f000000000000000000000000c65ef668114a1d0446f960ac4caa8c080efab78673ffffffffffffffffffffffffffffffffffffffff16636352211e836040518263ffffffff1660e01b815260040161146691906129b4565b602060405180830381865afa158015611483573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114a791906129e4565b73ffffffffffffffffffffffffffffffffffffffff16146114fd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114f490612a5d565b60405180910390fd5b50565b3373ffffffffffffffffffffffffffffffffffffffff167f00000000000000000000000042fe737749683595e4315b443eadcc9346a994d973ffffffffffffffffffffffffffffffffffffffff16636352211e846040518263ffffffff1660e01b815260040161157091906129b4565b602060405180830381865afa15801561158d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115b191906129e4565b73ffffffffffffffffffffffffffffffffffffffff1614611607576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115fe90612ac9565b60405180910390fd5b3373ffffffffffffffffffffffffffffffffffffffff167f00000000000000000000000042fe737749683595e4315b443eadcc9346a994d973ffffffffffffffffffffffffffffffffffffffff16636352211e836040518263ffffffff1660e01b815260040161167791906129b4565b602060405180830381865afa158015611694573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116b891906129e4565b73ffffffffffffffffffffffffffffffffffffffff161461170e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161170590612ac9565b60405180910390fd5b61171782611bf3565b15611757576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161174e90612b35565b60405180910390fd5b61176081611bf3565b61179f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161179690612ba1565b60405180910390fd5b5050565b7f000000000000000000000000c65ef668114a1d0446f960ac4caa8c080efab78673ffffffffffffffffffffffffffffffffffffffff1663e4623c1b83836040518363ffffffff1660e01b81526004016117fe929190612c2e565b600060405180830381600087803b15801561181857600080fd5b505af115801561182c573d6000803e3d6000fd5b505050505050565b7f00000000000000000000000042fe737749683595e4315b443eadcc9346a994d973ffffffffffffffffffffffffffffffffffffffff1663e4623c1b83836040518363ffffffff1660e01b815260040161188f929190612c2e565b600060405180830381600087803b1580156118a957600080fd5b505af11580156118bd573d6000803e3d6000fd5b505050505050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ca6ed8d4338585856040518563ffffffff1660e01b81526004016119269493929190612dd2565b600060405180830381600087803b15801561194057600080fd5b505af1158015611954573d6000803e3d6000fd5b50505050505050565b611965611c0b565b73ffffffffffffffffffffffffffffffffffffffff166119836107f5565b73ffffffffffffffffffffffffffffffffffffffff16146119d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119d090612e6a565b60405180910390fd5b565b6119e3611c13565b60008060006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa611a26611c0b565b604051611a339190611f14565b60405180910390a1565b60008060019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600060016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b611b0a610d65565b60016000806101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258611b4d611c0b565b604051611b5a9190611f14565b60405180910390a1565b6000806000611b738585611c5c565b9150915060006004811115611b8b57611b8a612e8a565b5b816004811115611b9e57611b9d612e8a565b5b148015611bd657508573ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16145b80611be85750611be7868686611cad565b5b925050509392505050565b600080600283611c039190612eb9565b149050919050565b600033905090565b611c1b610721565b611c5a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c5190612f36565b60405180910390fd5b565b6000806041835103611c9d5760008060006020860151925060408601519150606086015160001a9050611c9187828585611df1565b94509450505050611ca6565b60006002915091505b9250929050565b60008060008573ffffffffffffffffffffffffffffffffffffffff16631626ba7e60e01b8686604051602401611ce4929190612ff5565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050604051611d4e9190613061565b600060405180830381855afa9150503d8060008114611d89576040519150601f19603f3d011682016040523d82523d6000602084013e611d8e565b606091505b5091509150818015611da257506020815110155b8015611de65750631626ba7e60e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681806020019051810190611de491906130a4565b145b925050509392505050565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08360001c1115611e2c576000600391509150611eca565b600060018787878760405160008152602001604052604051611e5194939291906130ed565b6020604051602081039080840390855afa158015611e73573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603611ec157600060019250925050611eca565b80600092509250505b94509492505050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000611efe82611ed3565b9050919050565b611f0e81611ef3565b82525050565b6000602082019050611f296000830184611f05565b92915050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b60008083601f840112611f5e57611f5d611f39565b5b8235905067ffffffffffffffff811115611f7b57611f7a611f3e565b5b602083019150836020820283011115611f9757611f96611f43565b5b9250929050565b6000819050919050565b611fb181611f9e565b8114611fbc57600080fd5b50565b600081359050611fce81611fa8565b92915050565b60008083601f840112611fea57611fe9611f39565b5b8235905067ffffffffffffffff81111561200757612006611f3e565b5b60208301915083600182028301111561202357612022611f43565b5b9250929050565b600080600080600080600080600060a08a8c03121561204c5761204b611f2f565b5b60008a013567ffffffffffffffff81111561206a57612069611f34565b5b6120768c828d01611f48565b995099505060208a013567ffffffffffffffff81111561209957612098611f34565b5b6120a58c828d01611f48565b975097505060408a013567ffffffffffffffff8111156120c8576120c7611f34565b5b6120d48c828d01611f48565b955095505060606120e78c828d01611fbf565b93505060808a013567ffffffffffffffff81111561210857612107611f34565b5b6121148c828d01611fd4565b92509250509295985092959850929598565b60008115159050919050565b61213b81612126565b82525050565b60006020820190506121566000830184612132565b92915050565b61216581611ef3565b811461217057600080fd5b50565b6000813590506121828161215c565b92915050565b60006020828403121561219e5761219d611f2f565b5b60006121ac84828501612173565b91505092915050565b6000819050919050565b60006121da6121d56121d084611ed3565b6121b5565b611ed3565b9050919050565b60006121ec826121bf565b9050919050565b60006121fe826121e1565b9050919050565b61220e816121f3565b82525050565b60006020820190506122296000830184612205565b92915050565b600061223a826121e1565b9050919050565b61224a8161222f565b82525050565b60006020820190506122656000830184612241565b92915050565b600082825260208201905092915050565b7f43453a2057726f6e67207369676e617475726500000000000000000000000000600082015250565b60006122b260138361226b565b91506122bd8261227c565b602082019050919050565b600060208201905081810360008301526122e1816122a5565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061235182611f9e565b915061235c83611f9e565b92508261236c5761236b6122e8565b5b828204905092915050565b7f43454d3a2057726f6e672073697a652034000000000000000000000000000000600082015250565b60006123ad60118361226b565b91506123b882612377565b602082019050919050565b600060208201905081810360008301526123dc816123a0565b9050919050565b7f43454d3a2057726f6e672073697a652035360000000000000000000000000000600082015250565b600061241960128361226b565b9150612424826123e3565b602082019050919050565b600060208201905081810360008301526124488161240c565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60006124b882611f9e565b91506124c383611f9e565b92508282019050808211156124db576124da612317565b5b92915050565b7f43454d3a20436c61696d204e6f742030206f7220310000000000000000000000600082015250565b600061251760158361226b565b9150612522826124e1565b602082019050919050565b600060208201905081810360008301526125468161250a565b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b60006125a960268361226b565b91506125b48261254d565b604082019050919050565b600060208201905081810360008301526125d88161259c565b9050919050565b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b600061261560108361226b565b9150612620826125df565b602082019050919050565b6000602082019050818103600083015261264481612608565b9050919050565b600081905092915050565b600080fd5b82818337505050565b6000612670838561264b565b93507f07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8311156126a3576126a2612656565b5b6020830292506126b483858461265b565b82840190509392505050565b6000819050919050565b6126db6126d682611f9e565b6126c0565b82525050565b60008160601b9050919050565b60006126f9826126e1565b9050919050565b600061270b826126ee565b9050919050565b61272361271e82611ef3565b612700565b82525050565b6000612736828a8c612664565b915061274382888a612664565b9150612750828688612664565b915061275c82856126ca565b60208201915061276c8284612712565b6014820191508190509998505050505050505050565b600081905092915050565b7f19457468657265756d205369676e6564204d6573736167653a0a333200000000600082015250565b60006127c3601c83612782565b91506127ce8261278d565b601c82019050919050565b6000819050919050565b6000819050919050565b6127fe6127f9826127d9565b6127e3565b82525050565b600061280f826127b6565b915061281b82846127ed565b60208201915081905092915050565b7f43453a204e6f7420497373756520310000000000000000000000000000000000600082015250565b6000612860600f8361226b565b915061286b8261282a565b602082019050919050565b6000602082019050818103600083015261288f81612853565b9050919050565b7f43453a204e6f7420497373756520320000000000000000000000000000000000600082015250565b60006128cc600f8361226b565b91506128d782612896565b602082019050919050565b600060208201905081810360008301526128fb816128bf565b9050919050565b7f43453a204e6f7420497373756520330000000000000000000000000000000000600082015250565b6000612938600f8361226b565b915061294382612902565b602082019050919050565b600060208201905081810360008301526129678161292b565b9050919050565b61297781611f9e565b82525050565b60006060820190506129926000830186611f05565b61299f6020830185611f05565b6129ac604083018461296e565b949350505050565b60006020820190506129c9600083018461296e565b92915050565b6000815190506129de8161215c565b92915050565b6000602082840312156129fa576129f9611f2f565b5b6000612a08848285016129cf565b91505092915050565b7f43453a204e6f74206f776e657220340000000000000000000000000000000000600082015250565b6000612a47600f8361226b565b9150612a5282612a11565b602082019050919050565b60006020820190508181036000830152612a7681612a3a565b9050919050565b7f43453a204e6f74206f776e657220353600000000000000000000000000000000600082015250565b6000612ab360108361226b565b9150612abe82612a7d565b602082019050919050565b60006020820190508181036000830152612ae281612aa6565b9050919050565b7f43453a204e6f7420497373756520350000000000000000000000000000000000600082015250565b6000612b1f600f8361226b565b9150612b2a82612ae9565b602082019050919050565b60006020820190508181036000830152612b4e81612b12565b9050919050565b7f43453a204e6f7420497373756520360000000000000000000000000000000000600082015250565b6000612b8b600f8361226b565b9150612b9682612b55565b602082019050919050565b60006020820190508181036000830152612bba81612b7e565b9050919050565b600082825260208201905092915050565b6000612bde8385612bc1565b93507f07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff831115612c1157612c10612656565b5b602083029250612c2283858461265b565b82840190509392505050565b60006020820190508181036000830152612c49818486612bd2565b90509392505050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b612cb381611f9e565b82525050565b6000612cc58383612caa565b60208301905092915050565b6000602082019050919050565b6000612ce982612c7e565b612cf38185612c89565b9350612cfe83612c9a565b8060005b83811015612d2f578151612d168882612cb9565b9750612d2183612cd1565b925050600181019050612d02565b5085935050505092915050565b6000612d488383612cde565b905092915050565b6000602082019050919050565b6000612d6882612c52565b612d728185612c5d565b935083602082028501612d8485612c6e565b8060005b85811015612dc05784840389528151612da18582612d3c565b9450612dac83612d50565b925060208a01995050600181019050612d88565b50829750879550505050505092915050565b6000608082019050612de76000830187611f05565b612df4602083018661296e565b612e01604083018561296e565b8181036060830152612e138184612d5d565b905095945050505050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000612e5460208361226b565b9150612e5f82612e1e565b602082019050919050565b60006020820190508181036000830152612e8381612e47565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b6000612ec482611f9e565b9150612ecf83611f9e565b925082612edf57612ede6122e8565b5b828206905092915050565b7f5061757361626c653a206e6f7420706175736564000000000000000000000000600082015250565b6000612f2060148361226b565b9150612f2b82612eea565b602082019050919050565b60006020820190508181036000830152612f4f81612f13565b9050919050565b612f5f816127d9565b82525050565b600081519050919050565b600082825260208201905092915050565b60005b83811015612f9f578082015181840152602081019050612f84565b60008484015250505050565b6000601f19601f8301169050919050565b6000612fc782612f65565b612fd18185612f70565b9350612fe1818560208601612f81565b612fea81612fab565b840191505092915050565b600060408201905061300a6000830185612f56565b818103602083015261301c8184612fbc565b90509392505050565b600081905092915050565b600061303b82612f65565b6130458185613025565b9350613055818560208601612f81565b80840191505092915050565b600061306d8284613030565b915081905092915050565b613081816127d9565b811461308c57600080fd5b50565b60008151905061309e81613078565b92915050565b6000602082840312156130ba576130b9611f2f565b5b60006130c88482850161308f565b91505092915050565b600060ff82169050919050565b6130e7816130d1565b82525050565b60006080820190506131026000830187612f56565b61310f60208301866130de565b61311c6040830185612f56565b6131296060830184612f56565b9594505050505056fea2646970667358221220fdda2cd70a667c9f8f975ce2f43343324fe2b20281a92ade2d13b7f19f7d157c64736f6c63430008150033

0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f000000000000000000000000c65ef668114a1d0446f960ac4caa8c080efab78600000000000000000000000042fe737749683595e4315b443eadcc9346a994d9000000000000000000000000a4c5ae60e6f07a9cae8a6e3ba28003e3afd12d35

-----Decoded View---------------
Arg [0] : _huxley123 (address): 0x9Ca8887D13BC4591Ae36972702fDf9de2c97957f
Arg [1] : _huxley4 (address): 0xc65eF668114A1d0446F960Ac4cAa8c080eFAB786
Arg [2] : _huxley56 (address): 0x42fe737749683595e4315b443eadcC9346a994D9
Arg [3] : _ceToken (address): 0xA4c5ae60e6F07a9cae8A6e3bA28003E3aFD12d35

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000009ca8887d13bc4591ae36972702fdf9de2c97957f
Arg [1] : 000000000000000000000000c65ef668114a1d0446f960ac4caa8c080efab786
Arg [2] : 00000000000000000000000042fe737749683595e4315b443eadcc9346a994d9
Arg [3] : 000000000000000000000000a4c5ae60e6f07a9cae8a6e3ba28003e3afd12d35