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: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

import "erc721a/contracts/ERC721A.sol";

import "./HunabEventsAndErrors.sol";
import "./HunabMintConfig.sol";
import "./HunabPricingModel.sol";
import "./interfaces/IHunabRevolution.sol";
import "./utils/OnceLocker.sol";

/**
 * @title Hunab contract implementation.
 *
 * The price formulas are as follows:
 *
 * Mint Price = (Current Supply+1)^alpha / beta + gamma
 * Burn Price = Current Supply^alpha / beta + gamma
 *
 * where alpha = 1.625, beta = 18000, gamma = 0.
 *
 * Hunab whitepaper: https://hunab.gitbook.io/whitepaper.
 */
contract Hunab is
    Ownable,
    ERC721A,
    HunabPricingModel,
    HunabMintConfig,
    HunabEventsAndErrors,
    OnceLocker
{
    uint256 public constant ROYALTY_RATE = 500; // 5/100 royalty rate

    address public constant TREASURY_ADDRESS = 0x846c3CCD7c0C9531769b1B5b7bCE88ba9b3d81e2; // treasury address
    uint256 public constant TREASURY_RESERVED = 15; // reserved amount for the community treasury

    address public royaltyRecipient; // royalty recipient

    IHunabRevolution public hunabRevolution; // Hunab Revolution contract for redemption

    bool private _redemptionEnabled; // indicate if redemption is enabled
    uint256 public redemptionIndex; // current redemption index

    string private _tokenURI;

    /**
     * @notice Constructor.
     * @param tokenURI_ The token URI
     * @param royaltyRecipient_ The royalty recipient
     * @param authConfig_ The config for auth mint
     * @param publicConfig_ The config for public mint
     */
    constructor(
        string memory tokenURI_,
        address royaltyRecipient_,
        AuthMintConfig memory authConfig_,
        PublicMintConfig memory publicConfig_
    ) ERC721A("Hunab", "HUNAB") {
        _tokenURI = tokenURI_;
        royaltyRecipient = royaltyRecipient_;

        authConfig = authConfig_;
        publicConfig = publicConfig_;
    }

    /**
     * @notice Reserve for the community treasury. The method can only be called once.
     */
    function reserve() external payable onlyOwner once(this.reserve.selector) {
        _batchMint(TREASURY_ADDRESS, TREASURY_RESERVED);
    }

    /**
     * @notice Authorized mint for allowlist.
     * @param proof The merkle proof
     */
    function mint(bytes32[] calldata proof) external payable {
        if (!isAuthMintEnabled()) revert AuthMintNotEnabled();
        if (!isAuthorized(_msgSender(), proof)) revert NotAuthorized();

        if (authMinted[_msgSender()] + 1 > MAX_AUTH_MINT_PER_WALLET)
            revert MaxAuthMintPerWalletExceeded();
        if (totalAuthMinted + 1 > MAX_AUTH_MINT) revert MaxAuthMintExceeded();

        authMinted[_msgSender()]++;
        totalAuthMinted++;

        _mint(_msgSender());
    }

    /**
     * @notice Public mint.
     */
    function mint() external payable {
        if (!isPublicMintEnabled()) revert PublicMintNotEnabled();

        _mint(_msgSender());
    }

    /**
     * @notice Burn token.
     * @param tokenId The id of the token to be burned
     */
    function burn(uint256 tokenId) external {
        if (ownerOf(tokenId) != _msgSender()) revert NotTokenOwner();

        uint256 price = getBurnPrice(totalSupply());

        _burn(tokenId);

        _burnFundHandler(price);
    }

    /**
     * @notice Redeem the given Hunab token for the new Hunab Revolution token. The original token will be locked forever.
     * And `extractableFund` will be transferred to the Hunab Revolution contract.
     * @param tokenId The id of the Hunab token to be redeemed
     */
    function redeem(uint256 tokenId) external {
        if (!isRedemptionEnabled()) revert RedemptionNotEnabled();

        transferFrom(_msgSender(), address(this), tokenId);
        uint256 newTokenId = hunabRevolution.hunabMint(_msgSender(), tokenId);

        uint256 extractableFund = getExtractableFund(++redemptionIndex);
        Address.sendValue(payable(address(hunabRevolution)), extractableFund);

        emit Redeemed(tokenId, newTokenId, extractableFund);
    }

    /**
     * @notice Set config for auth mint.
     * @param startTime The start time
     * @param endTime The end time
     * @param verificationRoot The merkle root
     */
    function setAuthConfig(
        uint64 startTime,
        uint64 endTime,
        bytes32 verificationRoot
    ) external onlyOwner {
        if (startTime != 0) {
            authConfig.startTime = startTime;
        }

        if (endTime != 0) {
            if (endTime <= authConfig.startTime) revert InvalidParams();
            authConfig.endTime = endTime;
        }

        if (verificationRoot != 0x0) {
            authConfig.verificationRoot = verificationRoot;
        }
    }

    /**
     * @notice Set config for public mint.
     * @param startTime The start time
     */
    function setPublicConfig(uint64 startTime) external onlyOwner {
        publicConfig.startTime = startTime;
    }

    /**
     * @notice Set royalty recipient.
     * @param newRoyaltyRecipient The new royalty recipient
     */
    function setRoyaltyRecipient(
        address newRoyaltyRecipient
    ) external onlyOwner {
        royaltyRecipient = newRoyaltyRecipient;
    }

    /**
     * @notice Set the Hunab Revolution contract.
     * @param hunabRevolution_ The Hunab Revolution contract
     */
    function setHunabRevolution(
        IHunabRevolution hunabRevolution_
    ) external onlyOwner {
        hunabRevolution = hunabRevolution_;
    }

    /**
     * @notice Set the redemption status.
     * @param redemptionEnabled The redemption status
     */
    function setRedemptionStatus(bool redemptionEnabled) external onlyOwner {
        _redemptionEnabled = redemptionEnabled;
    }

    /**
     * @notice Set the token URI.
     * @param newTokenURI The new token URI
     */
    function setTokenURI(string memory newTokenURI) external onlyOwner {
        _tokenURI = newTokenURI;
    }

    function _mint(address to) internal {
        uint256 price = getMintPrice(totalSupply());
        _mintFundHandler(price);

        _safeMint(to, 1);
    }

    function _batchMint(address to, uint256 quantity) internal {
        uint256 currentSupply = totalSupply();
        uint256 totalPrice;

        for (uint256 i = 0; i < quantity; i++) {
            uint256 price = getMintPrice(currentSupply + i);
            totalPrice += price;
        }

        _mintFundHandler(totalPrice);

        _safeMint(to, quantity);
    }

    function _mintFundHandler(uint256 price) internal {
        uint256 royalty = _getRoyalty(price);
        uint256 priceWithFee = price + royalty;

        if (msg.value < priceWithFee) revert InsufficientValue();

        _payRoyalty(royalty);

        if (msg.value > priceWithFee) {
            payable(_msgSender()).transfer(msg.value - priceWithFee);
        }
    }

    function _burnFundHandler(uint256 price) internal {
        uint256 royalty = _getRoyalty(price);
        _payRoyalty(royalty);

        payable(_msgSender()).transfer(price - royalty);
    }

    function _payRoyalty(uint256 royalty) internal {
        payable(royaltyRecipient).transfer(royalty);
    }

    function _getRoyalty(
        uint256 price
    ) internal pure returns (uint256 royalty) {
        return (price * ROYALTY_RATE) / 10000;
    }

    /**
     * @notice Check if the auth mint is enabled.
     * @return bool True if the auth mint is enabled, false otherwise
     */
    function isAuthMintEnabled() public view returns (bool) {
        return
            authConfig.startTime != 0 &&
            block.timestamp >= authConfig.startTime &&
            authConfig.endTime != 0 &&
            block.timestamp < authConfig.endTime &&
            authConfig.verificationRoot != 0x0;
    }

    /**
     * @notice Check if the public mint is enabled.
     * @return bool True if the public mint is enabled, false otherwise
     */
    function isPublicMintEnabled() public view returns (bool) {
        return
            publicConfig.startTime != 0 &&
            block.timestamp >= publicConfig.startTime;
    }

    /**
     * @notice Check if redemption is enabled.
     * @return bool True if redemption is enabled, false otherwise
     */
    function isRedemptionEnabled() public view returns (bool) {
        return _redemptionEnabled;
    }

    /**
     * @notice Verify whether the given account is authorized.
     * @param account The destination address to be verified
     * @param proof The merkle proof
     * @return authorized True if the given address is authorized, false otherwise
     */
    function isAuthorized(
        address account,
        bytes32[] calldata proof
    ) public view returns (bool) {
        return
            MerkleProof.verify(
                proof,
                authConfig.verificationRoot,
                keccak256(abi.encodePacked(account))
            );
    }

    /**
     * @notice Get the mint price plus royalty by the given total supply.
     * @param totalSupply The total supply
     * @return price The final mint price
     */
    function getMintPriceAfterFee(
        uint256 totalSupply
    ) public pure returns (uint256) {
        uint256 price = getMintPrice(totalSupply);
        uint256 royalty = _getRoyalty(price);

        return price + royalty;
    }

    /**
     * @notice Get the burn price minus royalty by the given total supply.
     * @param totalSupply The total supply
     * @return price The final burn price
     */
    function getBurnPriceAfterFee(
        uint256 totalSupply
    ) public pure returns (uint256) {
        uint256 price = getBurnPrice(totalSupply);
        uint256 royalty = _getRoyalty(price);

        return price - royalty;
    }

    /**
     * @notice Get the current mint price plus royalty.
     * @return price The current mint price
     */
    function getCurrentMintPriceAfterFee() public view returns (uint256) {
        return getMintPriceAfterFee(totalSupply());
    }

    /**
     * @notice Get the current burn price minus royalty.
     * @return price The current burn price
     */
    function getCurrentBurnPriceAfterFee() public view returns (uint256) {
        return getBurnPriceAfterFee(totalSupply());
    }

    /**
     * @notice Get the batch mint price plus royalty by the given total supply and quantity.
     * @param totalSupply The total supply
     * @param quantity The quantity of tokens to be minted
     * @return The total mint price
     */
    function getBatchMintPriceAfterFee(
        uint256 totalSupply,
        uint256 quantity
    ) public pure returns (uint256) {
        uint256 totalPrice;

        for (uint256 i = 0; i < quantity; i++) {
            uint256 price = getMintPrice(totalSupply + i);
            totalPrice += price;
        }

        uint256 royalty = _getRoyalty(totalPrice);

        return totalPrice + royalty;
    }

    /**
     * @notice Get the batch burn price minus royalty by the given total supply and quantity.
     * @param totalSupply The total supply
     * @param quantity The quantity of tokens to be burned
     * @return The total burn price
     */
    function getBatchBurnPriceAfterFee(
        uint256 totalSupply,
        uint256 quantity
    ) public pure returns (uint256) {
        uint256 totalPrice;

        for (uint256 i = 0; i < quantity; i++) {
            uint256 price = getBurnPrice(totalSupply - i);
            totalPrice += price;
        }

        uint256 royalty = _getRoyalty(totalPrice);

        return totalPrice - royalty;
    }

    /**
     * @notice Get the total number of minted tokens.
     * @return totalNumber The total number of minted tokens
     */
    function totalMinted() public view returns (uint256) {
        return _totalMinted();
    }

    /**
     * @notice Get the total number of burned tokens.
     * @return totalNumber The total number of burned tokens
     */
    function totalBurned() public view returns (uint256) {
        return _totalBurned();
    }

    /**
     * @notice Override `ERC721A.tokenURI`.
     */
    function tokenURI(
        uint256 tokenId
    ) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert InvalidTokenId();

        return _tokenURI;
    }

    /**
     * @notice Override `ERC721A._startTokenId`.
     */
    function _startTokenId() internal view virtual override returns (uint256) {
        return 0;
    }

    /**
     * @notice Query all tokens of the given owner.
     * @param owner The destination owner
     * @return tokenIds The ids of tokens of the given owner
     */
    function tokensOfOwner(
        address owner
    ) external view returns (uint256[] memory) {
        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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/utils/math/Math.sol";

/**
 * @title Hunab pricing model by the bonding curve.
 *
 * See details in https://hunab.gitbook.io/whitepaper/core-concept/bonding-curve.
 */
contract HunabPricingModel {
    using Math for uint256;

    // alpha = 1.625, that is 13/8
    uint256 public constant ALPHA_NUMERATOR = 13; // numerator of the alpha factor
    uint256 public constant ALPHA_DENOMINATOR = 8; // denominator of the alpha factor

    uint256 public constant BETA = 18000; // beta factor
    uint256 public constant GAMMA = 0; // gamma factor

    /**
     * @notice Get the mint price by the given total supply.
     * @param totalSupply The total supply
     * @return price The mint price
     */
    function getMintPrice(uint256 totalSupply) public pure returns (uint256) {
        // alpha = 1.625
        // x^alpha = x^1.625 = (x^13)^1/8 = (((x^13)^1/2)^1/2)^1/2
        return
            (((totalSupply + 1) ** ALPHA_NUMERATOR).sqrt().sqrt().sqrt() *
                10 ** 18).ceilDiv(BETA) + GAMMA;
    }

    /**
     * @notice Get the burn price by the given total supply.
     * @param totalSupply The total supply
     * @return price The burn price
     */
    function getBurnPrice(uint256 totalSupply) public pure returns (uint256) {
        // refer to `getMintPrice`
        return
            ((totalSupply ** ALPHA_NUMERATOR).sqrt().sqrt().sqrt() * 10 ** 18)
                .ceilDiv(BETA) + GAMMA;
    }

    /**
     * @notice Get the extractable fund for the Hunab Revolution contract during redemption.
     * @param redemptionIndex The redemption index
     * @return extractableFund The extractable fund
     */
    function getExtractableFund(
        uint256 redemptionIndex
    ) public pure returns (uint256) {
        // refer to `getMintPrice`
        return
            ((redemptionIndex ** ALPHA_NUMERATOR).sqrt().sqrt().sqrt() *
                10 ** 18).ceilDiv(BETA) + GAMMA;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @title Hunab config for allowlist and public mint.
 */
contract HunabMintConfig {
    uint256 public constant MAX_AUTH_MINT_PER_WALLET = 3; // maximum mintable amount per allowlist address
    uint256 public constant MAX_AUTH_MINT = 600; // maximum mintable amount for the allowlist phase

    mapping(address => uint256) public authMinted;
    uint256 public totalAuthMinted;

    AuthMintConfig public authConfig;
    PublicMintConfig public publicConfig;

    // auth mint config
    struct AuthMintConfig {
        uint64 startTime;
        uint64 endTime;
        bytes32 verificationRoot;
    }

    // public mint config
    struct PublicMintConfig {
        uint64 startTime;
    }
}

// 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 (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// 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.2) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// 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

pragma solidity ^0.8.20;

/**
 * @title Events and errors for Hunab.
 */
abstract contract HunabEventsAndErrors {
    /**
     * Emitted when redemption completed.
     * @param tokenId The id of the redeemed token
     * @param newTokenId The id of the new token
     * @param extractedFund The extracted fund during redemption
     */
    event Redeemed(
        uint256 indexed tokenId,
        uint256 indexed newTokenId,
        uint256 extractedFund
    );

    /**
     * Auth mint is not enabled.
     */
    error AuthMintNotEnabled();

    /**
     * Public mint is not enabled.
     */
    error PublicMintNotEnabled();

    /**
     * Redemption is not enabled.
     */
    error RedemptionNotEnabled();

    /**
     * The account is not authorized.
     */
    error NotAuthorized();

    /**
     * Maximum auth mint limit per wallet exceeded.
     */
    error MaxAuthMintPerWalletExceeded();

    /**
     * Maximum auth mint limit exceeded.
     */
    error MaxAuthMintExceeded();

    /**
     * The account is not the token owner.
     */
    error NotTokenOwner();

    /**
     * Insufficient value.
     */
    error InsufficientValue();

    /**
     * Invalid params.
     */
    error InvalidParams();

    /**
     * Invalid token id.
     */
    error InvalidTokenId();
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @title Interface for the Hunab Revolution contract.
 */
interface IHunabRevolution {
    /**
     * @dev Mint token to the specified recipient for Hunab.
     * @param to The recipient address
     * @param hunabTokenId The id of the original Hunab token
     * @return tokenId The id of the minted token
     */
    function hunabMint(
        address to,
        uint256 hunabTokenId
    ) external returns (uint256 tokenId);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @title Contract for one time call locker.
 */
contract OnceLocker {
    mapping(bytes4 => bool) private _locked;

    /**
     * @dev Ensure that the underlying method can only be called once.
     * @param method The underlying method selector
     */
    modifier once(bytes4 method) {
        require(!_isLocked(method), "OnceLocker: the method has been called");

        _lock(method);

        _;
    }

    /**
     * @dev Lock the given method.
     * @param method The given method selector
     */
    function _lock(bytes4 method) private {
        _locked[method] = true;
    }

    /**
     * @dev Check if the given method is locked.
     * @param method The given method selector
     * @return bool True if the given method has been called, false otherwise
     */
    function _isLocked(bytes4 method) private view returns (bool) {
        return _locked[method];
    }
}

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

pragma solidity ^0.8.4;

import './IERC721A.sol';

/**
 * @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)
        }
    }
}

// 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);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "shanghai",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"tokenURI_","type":"string"},{"internalType":"address","name":"royaltyRecipient_","type":"address"},{"components":[{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint64","name":"endTime","type":"uint64"},{"internalType":"bytes32","name":"verificationRoot","type":"bytes32"}],"internalType":"struct HunabMintConfig.AuthMintConfig","name":"authConfig_","type":"tuple"},{"components":[{"internalType":"uint64","name":"startTime","type":"uint64"}],"internalType":"struct HunabMintConfig.PublicMintConfig","name":"publicConfig_","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"AuthMintNotEnabled","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InsufficientValue","type":"error"},{"inputs":[],"name":"InvalidParams","type":"error"},{"inputs":[],"name":"InvalidTokenId","type":"error"},{"inputs":[],"name":"MaxAuthMintExceeded","type":"error"},{"inputs":[],"name":"MaxAuthMintPerWalletExceeded","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"NotAuthorized","type":"error"},{"inputs":[],"name":"NotTokenOwner","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","type":"error"},{"inputs":[],"name":"PublicMintNotEnabled","type":"error"},{"inputs":[],"name":"RedemptionNotEnabled","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"},{"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"extractedFund","type":"uint256"}],"name":"Redeemed","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":[],"name":"ALPHA_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ALPHA_NUMERATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BETA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GAMMA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_AUTH_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_AUTH_MINT_PER_WALLET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROYALTY_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TREASURY_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TREASURY_RESERVED","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"authConfig","outputs":[{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint64","name":"endTime","type":"uint64"},{"internalType":"bytes32","name":"verificationRoot","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"authMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"getBatchBurnPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"getBatchMintPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"getBurnPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"getBurnPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getCurrentBurnPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentMintPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"redemptionIndex","type":"uint256"}],"name":"getExtractableFund","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"getMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"getMintPriceAfterFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"hunabRevolution","outputs":[{"internalType":"contract IHunabRevolution","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":[],"name":"isAuthMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"isAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRedemptionEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"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":"","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":[],"name":"publicConfig","outputs":[{"internalType":"uint64","name":"startTime","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"redemptionIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reserve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"royaltyRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint64","name":"endTime","type":"uint64"},{"internalType":"bytes32","name":"verificationRoot","type":"bytes32"}],"name":"setAuthConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IHunabRevolution","name":"hunabRevolution_","type":"address"}],"name":"setHunabRevolution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"startTime","type":"uint64"}],"name":"setPublicConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"redemptionEnabled","type":"bool"}],"name":"setRedemptionStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRoyaltyRecipient","type":"address"}],"name":"setRoyaltyRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newTokenURI","type":"string"}],"name":"setTokenURI","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":[],"name":"totalAuthMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","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":"nonpayable","type":"function"}]

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

0x608060405260043610610387575f3560e01c80638da5cb5b116101d3578063cd3293de116100fd578063eae55cab1161009d578063f2fde38b1161006d578063f2fde38b146109c7578063f37337ed146109e6578063f6885ea114610a05578063fccfb83f14610a30575f80fd5b8063eae55cab14610977578063eba0df6e1461098c578063f18c28f31461099f578063f1e3948a146109b3575f80fd5b8063e0df5b6f116100d8578063e0df5b6f146108a8578063e38158a8146108c7578063e68d84f2146108db578063e985e9c514610930575f80fd5b8063cd3293de1461086d578063d89135cd14610875578063db006a7514610889575f80fd5b8063b77a147b11610173578063c178268511610143578063c1782685146107fb578063c7ab4ca91461081a578063c87b56dd14610839578063ccee258314610858575f80fd5b8063b77a147b146107ac578063b88d4fde146107bf578063bdc4a575146107d2578063be28e4d5146107e6575f80fd5b8063a2309ff8116101ae578063a2309ff81461072e578063a6599ded14610742578063b169552f14610779578063b27857991461078d575f80fd5b80638da5cb5b146106df57806395d89b41146106fb578063a22cb4651461070f575f80fd5b806342842e0e116102b45780635f3b29481161025457806370a082311161022457806370a082311461066c578063715018a61461068b57806382d00ba81461069f5780638462151c146106b3575f80fd5b80635f3b2948146105f05780636352211e1461060f5780636c830c011461062e5780637058d4611461064d575f80fd5b80634c9b1a761161028f5780634c9b1a76146105805780634ccdb6ff1461059457806351e3ebed146105b2578063559e775b146105d1575f80fd5b806342842e0e1461052f57806342966c68146105425780634c00de8214610561575f80fd5b80631249c58b1161032a578063346fd5dd116102fa578063346fd5dd146104aa57806337b716d1146104dc57806340e37ff1146104fb57806341e42f3014610510575f80fd5b80631249c58b1461048a57806318160ddd146104925780631885c020146104aa57806323b872dd146104c9575f80fd5b8063071a754111610365578063071a7541146103f457806307604b1a14610417578063081812fc14610456578063095ea7b314610475575f80fd5b80630116bc2d1461038b57806301ffc9a7146103b457806306fdde03146103d3575b5f80fd5b348015610396575f80fd5b5061039f610a4f565b60405190151581526020015b60405180910390f35b3480156103bf575f80fd5b5061039f6103ce36600461230a565b610a7b565b3480156103de575f80fd5b506103e7610acc565b6040516103ab9190612368565b3480156103ff575f80fd5b5061040961465081565b6040519081526020016103ab565b348015610422575f80fd5b5061043e73846c3ccd7c0c9531769b1b5b7bce88ba9b3d81e281565b6040516001600160a01b0390911681526020016103ab565b348015610461575f80fd5b5061043e61047036600461237a565b610b5c565b6104886104833660046123a5565b610b9e565b005b610488610c3c565b34801561049d575f80fd5b5060025460015403610409565b3480156104b5575f80fd5b506104096104c436600461237a565b610c71565b6104886104d73660046123cf565b610cb0565b3480156104e7575f80fd5b506104886104f636600461240d565b610e38565b348015610506575f80fd5b506104096101f481565b34801561051b575f80fd5b5061048861052a36600461240d565b610e62565b61048861053d3660046123cf565b610e8c565b34801561054d575f80fd5b5061048861055c36600461237a565b610eab565b34801561056c575f80fd5b50600f5461043e906001600160a01b031681565b34801561058b575f80fd5b50610409600381565b34801561059f575f80fd5b50601054600160a01b900460ff1661039f565b3480156105bd575f80fd5b506104886105cc366004612443565b610f05565b3480156105dc575f80fd5b506104096105eb36600461237a565b610f30565b3480156105fb575f80fd5b5060105461043e906001600160a01b031681565b34801561061a575f80fd5b5061043e61062936600461237a565b610f56565b348015610639575f80fd5b5061048861064836600461246b565b610f60565b348015610658575f80fd5b5061040961066736600461237a565b610f86565b348015610677575f80fd5b5061040961068636600461240d565b610fb1565b348015610696575f80fd5b50610488610ffd565b3480156106aa575f80fd5b50610409600f81565b3480156106be575f80fd5b506106d26106cd36600461240d565b61100e565b6040516103ab9190612484565b3480156106ea575f80fd5b505f546001600160a01b031661043e565b348015610706575f80fd5b506103e761111e565b34801561071a575f80fd5b506104886107293660046124bb565b61112d565b348015610739575f80fd5b50610409611198565b34801561074d575f80fd5b50600d54610761906001600160401b031681565b6040516001600160401b0390911681526020016103ab565b348015610784575f80fd5b506104096111a2565b348015610798575f80fd5b506104096107a73660046124ee565b6111b3565b6104886107ba366004612555565b61120f565b6104886107cd366004612619565b611306565b3480156107dd575f80fd5b50610409600d81565b3480156107f1575f80fd5b50610409600a5481565b348015610806575f80fd5b50610488610815366004612693565b611350565b348015610825575f80fd5b5061040961083436600461237a565b6113fa565b348015610844575f80fd5b506103e761085336600461237a565b61141d565b348015610863575f80fd5b5061040961025881565b6104886114d5565b348015610880575f80fd5b506104096115be565b348015610894575f80fd5b506104886108a336600461237a565b6115c8565b3480156108b3575f80fd5b506104886108c23660046126cc565b6116f6565b3480156108d2575f80fd5b5061039f61170a565b3480156108e6575f80fd5b50600b54600c5461090a916001600160401b0380821692600160401b909204169083565b604080516001600160401b039485168152939092166020840152908201526060016103ab565b34801561093b575f80fd5b5061039f61094a366004612710565b6001600160a01b039182165f90815260086020908152604080832093909416825291909152205460ff1690565b348015610982575f80fd5b5061040960115481565b348015610997575f80fd5b506104095f81565b3480156109aa575f80fd5b5061040961177b565b3480156109be575f80fd5b50610409600881565b3480156109d2575f80fd5b506104886109e136600461240d565b61178c565b3480156109f1575f80fd5b50610409610a003660046124ee565b611802565b348015610a10575f80fd5b50610409610a1f36600461240d565b60096020525f908152604090205481565b348015610a3b575f80fd5b5061039f610a4a366004612747565b611855565b600d545f906001600160401b031615801590610a765750600d546001600160401b03164210155b905090565b5f6301ffc9a760e01b6001600160e01b031983161480610aab57506380ac58cd60e01b6001600160e01b03198316145b80610ac65750635b5e139f60e01b6001600160e01b03198316145b92915050565b606060038054610adb90612797565b80601f0160208091040260200160405190810160405280929190818152602001828054610b0790612797565b8015610b525780601f10610b2957610100808354040283529160200191610b52565b820191905f5260205f20905b815481529060010190602001808311610b3557829003601f168201915b5050505050905090565b5f610b66826118cb565b610b83576040516333d1c03960e21b815260040160405180910390fd5b505f908152600760205260409020546001600160a01b031690565b5f610ba882610f56565b9050336001600160a01b03821614610be157610bc4813361094a565b610be1576040516367d9dca160e11b815260040160405180910390fd5b5f8281526007602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b610c44610a4f565b610c61576040516393e8222560e01b815260040160405180910390fd5b610c6f336118f1565b6118f1565b565b5f80610ca6614650610c8e610c898080600d896128c3565b611918565b610ca090670de0b6b3a76400006128ce565b90611a03565b610ac691906128e5565b5f610cba82611a38565b9050836001600160a01b0316816001600160a01b031614610ced5760405162a1148160e81b815260040160405180910390fd5b5f8281526007602052604090208054610d188187335b6001600160a01b039081169116811491141790565b610d4357610d26863361094a565b610d4357604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b038516610d6a57604051633a954ecd60e21b815260040160405180910390fd5b8015610d74575f82555b6001600160a01b038681165f9081526006602052604080822080545f19019055918716808252919020805460010190554260a01b17600160e11b175f85815260056020526040812091909155600160e11b84169003610e0157600184015f818152600560205260408120549003610dff576001548114610dff575f8181526005602052604090208490555b505b83856001600160a01b0316876001600160a01b03165f80516020612ad983398151915260405160405180910390a45b505050505050565b610e40611a9a565b601080546001600160a01b0319166001600160a01b0392909216919091179055565b610e6a611a9a565b600f80546001600160a01b0319166001600160a01b0392909216919091179055565b610ea683838360405180602001604052805f815250611306565b505050565b33610eb582610f56565b6001600160a01b031614610edc576040516359dc379f60e01b815260040160405180910390fd5b5f610eed6104c46002546001540390565b9050610ef882611af3565b610f0181611afd565b5050565b610f0d611a9a565b600d805467ffffffffffffffff19166001600160401b0392909216919091179055565b5f80610ca6614650610c8e610c8980600d610f4c8960016128e5565b610c8991906128c3565b5f610ac682611a38565b610f68611a9a565b60108054911515600160a01b0260ff60a01b19909216919091179055565b5f80610f9183610f30565b90505f610f9d82611b45565b9050610fa981836128e5565b949350505050565b5f6001600160a01b038216610fd9576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03165f908152600660205260409020546001600160401b031690565b611005611a9a565b610c6f5f611b5f565b60605f805f61101c85610fb1565b90505f816001600160401b0381111561103757611037612593565b604051908082528060200260200182016040528015611060578160200160208202803683370190505b50905061108c604080516080810182525f80825260208201819052918101829052606081019190915290565b5f5b8386146111125761109e81611bae565b915081604001516111025781516001600160a01b0316156110be57815194505b876001600160a01b0316856001600160a01b031603611102578083876110e3816128f8565b9850815181106110f5576110f5612910565b6020026020010181815250505b61110b816128f8565b905061108e565b50909695505050505050565b606060048054610adb90612797565b335f8181526008602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b5f610a7660015490565b5f610a766106676002546001540390565b5f805f5b838110156111ef575f6111cd6105eb83886128e5565b90506111d981846128e5565b92505080806111e7906128f8565b9150506111b7565b505f6111fa82611b45565b905061120681836128e5565b95945050505050565b61121761170a565b611234576040516316f3e84360e21b815260040160405180910390fd5b61123f338383611855565b61125c5760405163ea8e4eb560e01b815260040160405180910390fd5b335f908152600960205260409020546003906112799060016128e5565b111561129857604051631caee2a360e21b815260040160405180910390fd5b610258600a5460016112aa91906128e5565b11156112c95760405163162eba1b60e11b815260040160405180910390fd5b335f9081526009602052604081208054916112e3836128f8565b9091555050600a8054905f6112f7836128f8565b9190505550610f01610c6a3390565b611311848484610cb0565b6001600160a01b0383163b1561134a5761132d84848484611c2a565b61134a576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b611358611a9a565b6001600160401b0383161561138457600b805467ffffffffffffffff19166001600160401b0385161790555b6001600160401b038216156113ed57600b546001600160401b03908116908316116113c257604051635435b28960e11b815260040160405180910390fd5b600b80546fffffffffffffffff00000000000000001916600160401b6001600160401b038516021790555b8015610ea657600c555050565b5f8061140583610c71565b90505f61141182611b45565b9050610fa98183612924565b6060611428826118cb565b611445576040516307ed98ed60e31b815260040160405180910390fd5b6012805461145290612797565b80601f016020809104026020016040519081016040528092919081815260200182805461147e90612797565b80156114c95780601f106114a0576101008083540402835291602001916114c9565b820191905f5260205f20905b8154815290600101906020018083116114ac57829003601f168201915b50505050509050919050565b6114dd611a9a565b63669949ef60e11b5f819052600e6020527fb00411d760260a969569fd6fa81d98a20cc79675f76f605be62fe6fc5ecfc6a65460ff16156115745760405162461bcd60e51b815260206004820152602660248201527f4f6e63654c6f636b65723a20746865206d6574686f6420686173206265656e2060448201526518d85b1b195960d21b60648201526084015b60405180910390fd5b61159c816001600160e01b0319165f908152600e60205260409020805460ff19166001179055565b6115bb73846c3ccd7c0c9531769b1b5b7bce88ba9b3d81e2600f611d11565b50565b5f610a7660025490565b601054600160a01b900460ff166115f257604051630248deb960e31b815260040160405180910390fd5b6115fd333083610cb0565b6010545f906001600160a01b0316636ea60ac7336040516001600160e01b031960e084901b1681526001600160a01b039091166004820152602481018590526044016020604051808303815f875af115801561165b573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061167f9190612937565b90505f61169d60115f8154611693906128f8565b9182905550610c71565b6010549091506116b6906001600160a01b031682611d70565b81837f87efe79f362036cc4820341f6a35939a512b18c3432c5e367a6cfd09d41d7483836040516116e991815260200190565b60405180910390a3505050565b6116fe611a9a565b6012610f018282612993565b600b545f906001600160401b0316158015906117315750600b546001600160401b03164210155b801561174e5750600b54600160401b90046001600160401b031615155b801561176b5750600b54600160401b90046001600160401b031642105b8015610a76575050600c54151590565b5f610a766108346002546001540390565b611794611a9a565b6001600160a01b0381166117f95760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161156b565b6115bb81611b5f565b5f805f5b8381101561183e575f61181c6104c48388612924565b905061182881846128e5565b9250508080611836906128f8565b915050611806565b505f61184982611b45565b90506112068183612924565b5f610fa98383808060200260200160405190810160405280939291908181526020018383602002808284375f9201919091525050600c546040516bffffffffffffffffffffffff1960608b901b166020820152909250603401905060405160208183030381529060405280519060200120611e85565b5f60015482108015610ac65750505f90815260056020526040902054600160e01b161590565b5f6119026105eb6002546001540390565b905061190d81611e9a565b610f01826001611f18565b5f815f0361192757505f919050565b5f600161193384611f31565b901c6001901b9050600181848161194c5761194c612a4e565b048201901c9050600181848161196457611964612a4e565b048201901c9050600181848161197c5761197c612a4e565b048201901c9050600181848161199457611994612a4e565b048201901c905060018184816119ac576119ac612a4e565b048201901c905060018184816119c4576119c4612a4e565b048201901c905060018184816119dc576119dc612a4e565b048201901c90506119fc818285816119f6576119f6612a4e565b04611fc4565b9392505050565b5f8215611a305781611a16600185612924565b611a209190612a62565b611a2b9060016128e5565b6119fc565b5f9392505050565b5f81600154811015611a81575f8181526005602052604081205490600160e01b82169003611a7f575b805f036119fc57505f19015f81815260056020526040902054611a61565b505b604051636f96cda160e11b815260040160405180910390fd5b5f546001600160a01b03163314610c6f5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161156b565b6115bb815f611fd9565b5f611b0782611b45565b9050611b1281612108565b336108fc611b208385612924565b6040518115909202915f818181858888f19350505050158015610ea6573d5f803e3d5ffd5b5f612710611b556101f4846128ce565b610ac69190612a62565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b604080516080810182525f8082526020820181905291810182905260608101919091525f82815260056020526040902054610ac690604080516080810182526001600160a01b038316815260a083901c6001600160401b03166020820152600160e01b831615159181019190915260e89190911c606082015290565b604051630a85bd0160e11b81525f906001600160a01b0385169063150b7a0290611c5e903390899088908890600401612a81565b6020604051808303815f875af1925050508015611c98575060408051601f3d908101601f19168201909252611c9591810190612abd565b60015b611cf4573d808015611cc5576040519150601f19603f3d011682016040523d82523d5f602084013e611cca565b606091505b5080515f03611cec576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050949350505050565b5f611d1f6002546001540390565b90505f805b83811015611d5c575f611d3a6105eb83866128e5565b9050611d4681846128e5565b9250508080611d54906128f8565b915050611d24565b50611d6681611e9a565b61134a8484611f18565b80471015611dc05760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e6365000000604482015260640161156b565b5f826001600160a01b0316826040515f6040518083038185875af1925050503d805f8114611e09576040519150601f19603f3d011682016040523d82523d5f602084013e611e0e565b606091505b5050905080610ea65760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d61792068617665207265766572746564000000000000606482015260840161156b565b5f82611e91858461213f565b14949350505050565b5f611ea482611b45565b90505f611eb182846128e5565b905080341015611ed45760405163044044a560e21b815260040160405180910390fd5b611edd82612108565b80341115610ea657336108fc611ef38334612924565b6040518115909202915f818181858888f1935050505015801561134a573d5f803e3d5ffd5b610f01828260405180602001604052805f81525061218b565b5f80608083901c15611f4557608092831c92015b604083901c15611f5757604092831c92015b602083901c15611f6957602092831c92015b601083901c15611f7b57601092831c92015b600883901c15611f8d57600892831c92015b600483901c15611f9f57600492831c92015b600283901c15611fb157600292831c92015b600183901c15610ac65760010192915050565b5f818310611fd257816119fc565b5090919050565b5f611fe383611a38565b9050805f80611fff865f90815260076020526040902080549091565b91509150841561203f57612014818433610d03565b61203f57612022833361094a565b61203f57604051632ce44b5f60e11b815260040160405180910390fd5b8015612049575f82555b6001600160a01b0383165f81815260066020526040902080546fffffffffffffffffffffffffffffffff0190554260a01b17600360e01b175f87815260056020526040812091909155600160e11b851690036120d357600186015f8181526005602052604081205490036120d15760015481146120d1575f8181526005602052604090208590555b505b60405186905f906001600160a01b038616905f80516020612ad9833981519152908390a4505060028054600101905550505050565b600f546040516001600160a01b039091169082156108fc029083905f818181858888f19350505050158015610f01573d5f803e3d5ffd5b5f81815b84518110156121835761216f8286838151811061216257612162612910565b60200260200101516121f6565b91508061217b816128f8565b915050612143565b509392505050565b6121958383612222565b6001600160a01b0383163b15610ea6576001548281035b6121be5f868380600101945086611c2a565b6121db576040516368d2bf6b60e11b815260040160405180910390fd5b8181106121ac5781600154146121ef575f80fd5b5050505050565b5f818310612210575f8281526020849052604090206119fc565b5f8381526020839052604090206119fc565b6001545f8290036122465760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b0383165f8181526006602090815260408083208054680100000000000000018802019055848352600590915281206001851460e11b4260a01b178317905582840190839083905f80516020612ad98339815191528180a4600183015b8181146122cc5780835f5f80516020612ad98339815191525f80a46001016122a9565b50815f036122ec57604051622e076360e81b815260040160405180910390fd5b60015550505050565b6001600160e01b0319811681146115bb575f80fd5b5f6020828403121561231a575f80fd5b81356119fc816122f5565b5f81518084525f5b818110156123495760208185018101518683018201520161232d565b505f602082860101526020601f19601f83011685010191505092915050565b602081525f6119fc6020830184612325565b5f6020828403121561238a575f80fd5b5035919050565b6001600160a01b03811681146115bb575f80fd5b5f80604083850312156123b6575f80fd5b82356123c181612391565b946020939093013593505050565b5f805f606084860312156123e1575f80fd5b83356123ec81612391565b925060208401356123fc81612391565b929592945050506040919091013590565b5f6020828403121561241d575f80fd5b81356119fc81612391565b80356001600160401b038116811461243e575f80fd5b919050565b5f60208284031215612453575f80fd5b6119fc82612428565b8035801515811461243e575f80fd5b5f6020828403121561247b575f80fd5b6119fc8261245c565b602080825282518282018190525f9190848201906040850190845b818110156111125783518352928401929184019160010161249f565b5f80604083850312156124cc575f80fd5b82356124d781612391565b91506124e56020840161245c565b90509250929050565b5f80604083850312156124ff575f80fd5b50508035926020909101359150565b5f8083601f84011261251e575f80fd5b5081356001600160401b03811115612534575f80fd5b6020830191508360208260051b850101111561254e575f80fd5b9250929050565b5f8060208385031215612566575f80fd5b82356001600160401b0381111561257b575f80fd5b6125878582860161250e565b90969095509350505050565b634e487b7160e01b5f52604160045260245ffd5b5f6001600160401b03808411156125c0576125c0612593565b604051601f8501601f19908116603f011681019082821181831017156125e8576125e8612593565b81604052809350858152868686011115612600575f80fd5b858560208301375f602087830101525050509392505050565b5f805f806080858703121561262c575f80fd5b843561263781612391565b9350602085013561264781612391565b92506040850135915060608501356001600160401b03811115612668575f80fd5b8501601f81018713612678575f80fd5b612687878235602084016125a7565b91505092959194509250565b5f805f606084860312156126a5575f80fd5b6126ae84612428565b92506126bc60208501612428565b9150604084013590509250925092565b5f602082840312156126dc575f80fd5b81356001600160401b038111156126f1575f80fd5b8201601f81018413612701575f80fd5b610fa9848235602084016125a7565b5f8060408385031215612721575f80fd5b823561272c81612391565b9150602083013561273c81612391565b809150509250929050565b5f805f60408486031215612759575f80fd5b833561276481612391565b925060208401356001600160401b0381111561277e575f80fd5b61278a8682870161250e565b9497909650939450505050565b600181811c908216806127ab57607f821691505b6020821081036127c957634e487b7160e01b5f52602260045260245ffd5b50919050565b634e487b7160e01b5f52601160045260245ffd5b600181815b8085111561281d57815f1904821115612803576128036127cf565b8085161561281057918102915b93841c93908002906127e8565b509250929050565b5f8261283357506001610ac6565b8161283f57505f610ac6565b8160018114612855576002811461285f5761287b565b6001915050610ac6565b60ff841115612870576128706127cf565b50506001821b610ac6565b5060208310610133831016604e8410600b841016171561289e575081810a610ac6565b6128a883836127e3565b805f19048211156128bb576128bb6127cf565b029392505050565b5f6119fc8383612825565b8082028115828204841417610ac657610ac66127cf565b80820180821115610ac657610ac66127cf565b5f60018201612909576129096127cf565b5060010190565b634e487b7160e01b5f52603260045260245ffd5b81810381811115610ac657610ac66127cf565b5f60208284031215612947575f80fd5b5051919050565b601f821115610ea6575f81815260208120601f850160051c810160208610156129745750805b601f850160051c820191505b81811015610e3057828155600101612980565b81516001600160401b038111156129ac576129ac612593565b6129c0816129ba8454612797565b8461294e565b602080601f8311600181146129f3575f84156129dc5750858301515b5f19600386901b1c1916600185901b178555610e30565b5f85815260208120601f198616915b82811015612a2157888601518255948401946001909101908401612a02565b5085821015612a3e57878501515f19600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b5f52601260045260245ffd5b5f82612a7c57634e487b7160e01b5f52601260045260245ffd5b500490565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f90612ab390830184612325565b9695505050505050565b5f60208284031215612acd575f80fd5b81516119fc816122f556feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa264697066735822122010789f2882f53e24776f52aa6bfe23c8616381bf5777eddb74f79f5ec23e39d564736f6c63430008140033

00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000fd5386cc847ca74e5b726f020761ef8a2d074f4700000000000000000000000000000000000000000000000000000000652761300000000000000000000000000000000000000000000000000000000065278b607a62d6268d8ab7375b58defa6a62d9e6378f1836c2e898e584dc1def6fd7384b0000000000000000000000000000000000000000000000000000000065278b600000000000000000000000000000000000000000000000000000000000000042697066733a2f2f6261667962656966676336716b32713561643575676a786c6972656a6b776f6f6479646d706b756d3268646f627278347a74763762326a63656975000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : tokenURI_ (string): ipfs://bafybeifgc6qk2q5ad5ugjxlirejkwoodydmpkum2hdobrx4ztv7b2jceiu
Arg [1] : royaltyRecipient_ (address): 0xfD5386CC847cA74E5B726f020761EF8A2D074f47
Arg [2] : authConfig_ (tuple): 
     Arg [1] : startTime (uint64): 1697079600
     Arg [2] : endTime (uint64): 1697090400
     Arg [3] : verificationRoot (bytes32): 0x7a62d6268d8ab7375b58defa6a62d9e6378f1836c2e898e584dc1def6fd7384b

Arg [3] : publicConfig_ (tuple): 
     Arg [1] : startTime (uint64): 1697090400


-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 000000000000000000000000fd5386cc847ca74e5b726f020761ef8a2d074f47
Arg [2] : 0000000000000000000000000000000000000000000000000000000065276130
Arg [3] : 0000000000000000000000000000000000000000000000000000000065278b60
Arg [4] : 7a62d6268d8ab7375b58defa6a62d9e6378f1836c2e898e584dc1def6fd7384b
Arg [5] : 0000000000000000000000000000000000000000000000000000000065278b60
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000042
Arg [7] : 697066733a2f2f6261667962656966676336716b32713561643575676a786c69
Arg [8] : 72656a6b776f6f6479646d706b756d3268646f627278347a74763762326a6365
Arg [9] : 6975000000000000000000000000000000000000000000000000000000000000

770:12793:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8095:178;;;;;;;;;;;;;:::i;:::-;;;179:14:13;;172:22;154:41;;142:2;127:18;8095:178:5;;;;;;;;9155:630:11;;;;;;;;;;-1:-1:-1;9155:630:11;;;;;:::i;:::-;;:::i;10039:98::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;526:36:8:-;;;;;;;;;;;;557:5;526:36;;;;;1391:25:13;;;1379:2;1364:18;526:36:8;1245:177:13;976:85:5;;;;;;;;;;;;1019:42;976:85;;;;;-1:-1:-1;;;;;1591:32:13;;;1573:51;;1561:2;1546:18;976:85:5;1427:203:13;16360:214:11;;;;;;;;;;-1:-1:-1;16360:214:11;;;;;:::i;:::-;;:::i;15812:398::-;;;;;;:::i;:::-;;:::i;:::-;;3001:137:5;;;:::i;5894:317:11:-;;;;;;;;;;-1:-1:-1;6164:12:11;;6148:13;;:28;5894:317;;1735:276:8;;;;;;;;;;-1:-1:-1;1735:276:8;;;;;:::i;:::-;;:::i;19903:2764:11:-;;;;;;:::i;:::-;;:::i;5523:147:5:-;;;;;;;;;;-1:-1:-1;5523:147:5;;;;;:::i;:::-;;:::i;905:42::-;;;;;;;;;;;;944:3;905:42;;5244:146;;;;;;;;;;-1:-1:-1;5244:146:5;;;;;:::i;:::-;;:::i;22758:187:11:-;;;;;;:::i;:::-;;:::i;3242:230:5:-;;;;;;;;;;-1:-1:-1;3242:230:5;;;;;:::i;:::-;;:::i;1186:31::-;;;;;;;;;;-1:-1:-1;1186:31:5;;;;-1:-1:-1;;;;;1186:31:5;;;152:52:7;;;;;;;;;;;;203:1;152:52;;8409:100:5;;;;;;;;;;-1:-1:-1;8484:18:5;;-1:-1:-1;;;8484:18:5;;;;8409:100;;5011:113;;;;;;;;;;-1:-1:-1;5011:113:5;;;;;:::i;:::-;;:::i;795:311:8:-;;;;;;;;;;-1:-1:-1;795:311:8;;;;;:::i;:::-;;:::i;1245:39:5:-;;;;;;;;;;-1:-1:-1;1245:39:5;;;;-1:-1:-1;;;;;1245:39:5;;;11391:150:11;;;;;;;;;;-1:-1:-1;11391:150:11;;;;;:::i;:::-;;:::i;5788:127:5:-;;;;;;;;;;-1:-1:-1;5788:127:5;;;;;:::i;:::-;;:::i;9260:232::-;;;;;;;;;;-1:-1:-1;9260:232:5;;;;;:::i;:::-;;:::i;7045:230:11:-;;;;;;;;;;-1:-1:-1;7045:230:11;;;;;:::i;:::-;;:::i;1824:101:0:-;;;;;;;;;;;;;:::i;1087:46:5:-;;;;;;;;;;;;1131:2;1087:46;;12781:780;;;;;;;;;;-1:-1:-1;12781:780:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1247:7:0;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;10208:102:11;;;;;;;;;;;;;:::i;16901:231::-;;;;;;;;;;-1:-1:-1;16901:231:11;;;;;:::i;:::-;;:::i;11857:91:5:-;;;;;;;;;;;;;:::i;486:36:7:-;;;;;;;;;;-1:-1:-1;486:36:7;;;;-1:-1:-1;;;;;486:36:7;;;;;;-1:-1:-1;;;;;5333:31:13;;;5315:50;;5303:2;5288:18;486:36:7;5171:200:13;10028:128:5;;;;;;;;;;;;;:::i;10660:403::-;;;;;;;;;;-1:-1:-1;10660:403:5;;;;;:::i;:::-;;:::i;2458:493::-;;;;;;:::i;:::-;;:::i;23526:396:11:-;;;;;;:::i;:::-;;:::i;356:44:8:-;;;;;;;;;;;;398:2;356:44;;411:30:7;;;;;;;;;;;;;;;;4418:489:5;;;;;;;;;;-1:-1:-1;4418:489:5;;;;;:::i;:::-;;:::i;9674:232::-;;;;;;;;;;-1:-1:-1;9674:232:5;;;;;:::i;:::-;;:::i;12242:192::-;;;;;;;;;;-1:-1:-1;12242:192:5;;;;;:::i;:::-;;:::i;259:43:7:-;;;;;;;;;;;;299:3;259:43;;2215:138:5;;;:::i;12085:91::-;;;;;;;;;;;;;:::i;3763:471::-;;;;;;;;;;-1:-1:-1;3763:471:5;;;;;:::i;:::-;;:::i;6015:107::-;;;;;;;;;;-1:-1:-1;6015:107:5;;;;;:::i;:::-;;:::i;7636:313::-;;;;;;;;;;;;;:::i;448:32:7:-;;;;;;;;;;-1:-1:-1;448:32:7;;;;;;-1:-1:-1;;;;;448:32:7;;;;-1:-1:-1;;;448:32:7;;;;;;;;;;;-1:-1:-1;;;;;9047:15:13;;;9029:34;;9099:15;;;;9094:2;9079:18;;9072:43;9131:18;;;9124:34;8980:2;8965:18;448:32:7;8794:370:13;17282:162:11;;;;;;;;;;-1:-1:-1;17282:162:11;;;;;:::i;:::-;-1:-1:-1;;;;;17402:25:11;;;17379:4;17402:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;17282:162;1409:30:5;;;;;;;;;;;;;;;;583:33:8;;;;;;;;;;;;615:1;583:33;;10279:128:5;;;;;;;;;;;;;:::i;439:45:8:-;;;;;;;;;;;;483:1;439:45;;2074:198:0;;;;;;;;;;-1:-1:-1;2074:198:0;;;;;:::i;:::-;;:::i;11317:403:5:-;;;;;;;;;;-1:-1:-1;11317:403:5;;;;;:::i;:::-;;:::i;360:45:7:-;;;;;;;;;;-1:-1:-1;360:45:7;;;;;:::i;:::-;;;;;;;;;;;;;;8775:304:5;;;;;;;;;;-1:-1:-1;8775:304:5;;;;;:::i;:::-;;:::i;8095:178::-;8182:12;:22;8147:4;;-1:-1:-1;;;;;8182:22:5;:27;;;;:84;;-1:-1:-1;8244:12:5;:22;-1:-1:-1;;;;;8244:22:5;8225:15;:41;;8182:84;8163:103;;8095:178;:::o;9155:630:11:-;9240:4;-1:-1:-1;;;;;;;;;9558:25:11;;;;:101;;-1:-1:-1;;;;;;;;;;9634:25:11;;;9558:101;:177;;;-1:-1:-1;;;;;;;;;;9710:25:11;;;9558:177;9539:196;9155:630;-1:-1:-1;;9155:630:11:o;10039:98::-;10093:13;10125:5;10118:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10039:98;:::o;16360:214::-;16436:7;16460:16;16468:7;16460;:16::i;:::-;16455:64;;16485:34;;-1:-1:-1;;;16485:34:11;;;;;;;;;;;16455:64;-1:-1:-1;16537:24:11;;;;:15;:24;;;;;:30;-1:-1:-1;;;;;16537:30:11;;16360:214::o;15812:398::-;15900:13;15916:16;15924:7;15916;:16::i;:::-;15900:32;-1:-1:-1;39523:10:11;-1:-1:-1;;;;;15947:28:11;;;15943:172;;15994:44;16011:5;39523:10;17282:162;:::i;15994:44::-;15989:126;;16065:35;;-1:-1:-1;;;16065:35:11;;;;;;;;;;;15989:126;16125:24;;;;:15;:24;;;;;;:35;;-1:-1:-1;;;;;;16125:35:11;-1:-1:-1;;;;;16125:35:11;;;;;;;;;16175:28;;16125:24;;16175:28;;;;;;;15890:320;15812:398;;:::o;3001:137:5:-;3049:21;:19;:21::i;:::-;3044:57;;3079:22;;-1:-1:-1;;;3079:22:5;;;;;;;;;;;3044:57;3112:19;39523:10:11;3112:5:5;:19::i;3118:12::-;3112:5;:19::i;:::-;3001:137::o;1735:276:8:-;1823:7;;1896:100;557:5;1897:57;:50;;;398:2;1898:15;:34;:::i;:::-;1897:41;:43::i;:57::-;:84;;1973:8;1897:84;:::i;:::-;1896:94;;:100::i;:::-;:108;;;;:::i;19903:2764:11:-;20040:27;20070;20089:7;20070:18;:27::i;:::-;20040:57;;20153:4;-1:-1:-1;;;;;20112:45:11;20128:19;-1:-1:-1;;;;;20112:45:11;;20108:86;;20166:28;;-1:-1:-1;;;20166:28:11;;;;;;;;;;;20108:86;20206:27;19036:24;;;:15;:24;;;;;19260:26;;20394:68;19260:26;20436:4;39523:10;20442:19;-1:-1:-1;;;;;18524:32:11;;;18370:28;;18651:20;;18673:30;;18648:56;;18074:646;20394:68;20389:179;;20481:43;20498:4;39523:10;17282:162;:::i;20481:43::-;20476:92;;20533:35;;-1:-1:-1;;;20533:35:11;;;;;;;;;;;20476:92;-1:-1:-1;;;;;20583:16:11;;20579:52;;20608:23;;-1:-1:-1;;;20608:23:11;;;;;;;;;;;20579:52;20774:15;20771:157;;;20912:1;20891:19;20884:30;20771:157;-1:-1:-1;;;;;21300:24:11;;;;;;;:18;:24;;;;;;21298:26;;-1:-1:-1;;21298:26:11;;;21368:22;;;;;;;;;21366:24;;-1:-1:-1;21366:24:11;;;14703:11;14678:23;14674:41;14661:63;-1:-1:-1;;;14661:63:11;21654:26;;;;:17;:26;;;;;:172;;;;-1:-1:-1;;;21943:47:11;;:52;;21939:617;;22047:1;22037:11;;22015:19;22168:30;;;:17;:30;;;;;;:35;;22164:378;;22304:13;;22289:11;:28;22285:239;;22449:30;;;;:17;:30;;;;;:52;;;22285:239;21997:559;21939:617;22600:7;22596:2;-1:-1:-1;;;;;22581:27:11;22590:4;-1:-1:-1;;;;;22581:27:11;-1:-1:-1;;;;;;;;;;;22581:27:11;;;;;;;;;22618:42;20030:2637;;;19903:2764;;;:::o;5523:147:5:-;1094:13:0;:11;:13::i;:::-;5629:15:5::1;:34:::0;;-1:-1:-1;;;;;;5629:34:5::1;-1:-1:-1::0;;;;;5629:34:5;;;::::1;::::0;;;::::1;::::0;;5523:147::o;5244:146::-;1094:13:0;:11;:13::i;:::-;5345:16:5::1;:38:::0;;-1:-1:-1;;;;;;5345:38:5::1;-1:-1:-1::0;;;;;5345:38:5;;;::::1;::::0;;;::::1;::::0;;5244:146::o;22758:187:11:-;22899:39;22916:4;22922:2;22926:7;22899:39;;;;;;;;;;;;:16;:39::i;:::-;22758:187;;;:::o;3242:230:5:-;39523:10:11;3296:16:5;3304:7;3296;:16::i;:::-;-1:-1:-1;;;;;3296:32:5;;3292:60;;3337:15;;-1:-1:-1;;;3337:15:5;;;;;;;;;;;3292:60;3363:13;3379:27;3392:13;6164:12:11;;6148:13;;:28;;5894:317;3379:27:5;3363:43;;3417:14;3423:7;3417:5;:14::i;:::-;3442:23;3459:5;3442:16;:23::i;:::-;3282:190;3242:230;:::o;5011:113::-;1094:13:0;:11;:13::i;:::-;5083:12:5::1;:34:::0;;-1:-1:-1;;5083:34:5::1;-1:-1:-1::0;;;;;5083:34:5;;;::::1;::::0;;;::::1;::::0;;5011:113::o;795:311:8:-;859:7;;989:102;557:5;990:59;:52;;398:2;992:15;:11;1006:1;992:15;:::i;:::-;991:36;;;;:::i;11391:150:11:-;11463:7;11505:27;11524:7;11505:18;:27::i;5788:127:5:-;1094:13:0;:11;:13::i;:::-;5870:18:5::1;:38:::0;;;::::1;;-1:-1:-1::0;;;5870:38:5::1;-1:-1:-1::0;;;;5870:38:5;;::::1;::::0;;;::::1;::::0;;5788:127::o;9260:232::-;9346:7;9365:13;9381:25;9394:11;9381:12;:25::i;:::-;9365:41;;9416:15;9434:18;9446:5;9434:11;:18::i;:::-;9416:36;-1:-1:-1;9470:15:5;9416:36;9470:5;:15;:::i;:::-;9463:22;9260:232;-1:-1:-1;;;;9260:232:5:o;7045:230:11:-;7117:7;-1:-1:-1;;;;;7140:19:11;;7136:60;;7168:28;;-1:-1:-1;;;7168:28:11;;;;;;;;;;;7136:60;-1:-1:-1;;;;;;7213:25:11;;;;;:18;:25;;;;;;-1:-1:-1;;;;;7213:55:11;;7045:230::o;1824:101:0:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;12781:780:5:-:0;12856:16;12884:19;12913:25;12949:22;12974:16;12984:5;12974:9;:16::i;:::-;12949:41;;13000:25;13042:14;-1:-1:-1;;;;;13028:29:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13028:29:5;;13000:57;;13068:31;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13068:31:5;13114:9;13109:420;13158:14;13143:11;:29;13109:420;;13205:15;13218:1;13205:12;:15::i;:::-;13193:27;;13239:9;:16;;;13275:8;13235:63;13316:14;;-1:-1:-1;;;;;13316:28:5;;13312:101;;13384:14;;;-1:-1:-1;13312:101:5;13452:5;-1:-1:-1;;;;;13431:26:5;:17;-1:-1:-1;;;;;13431:26:5;;13427:92;;13503:1;13477:8;13486:13;;;;:::i;:::-;;;13477:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;13427:92;13174:3;;;:::i;:::-;;;13109:420;;;-1:-1:-1;13546:8:5;;12781:780;-1:-1:-1;;;;;;12781:780:5:o;10208:102:11:-;10264:13;10296:7;10289:14;;;;;:::i;16901:231::-;39523:10;16995:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;16995:49:11;;;;;;;;;;;;:60;;-1:-1:-1;;16995:60:11;;;;;;;;;;17070:55;;154:41:13;;;16995:49:11;;39523:10;17070:55;;127:18:13;17070:55:11;;;;;;;16901:231;;:::o;11857:91:5:-;11901:7;11927:14;6546:13:11;;;6304:290;10028:128:5;10088:7;10114:35;10135:13;6164:12:11;;6148:13;;:28;;5894:317;10660:403:5;10777:7;10796:18;10830:9;10825:142;10849:8;10845:1;:12;10825:142;;;10878:13;10894:29;10907:15;10921:1;10907:11;:15;:::i;10894:29::-;10878:45;-1:-1:-1;10937:19:5;10878:45;10937:19;;:::i;:::-;;;10864:103;10859:3;;;;;:::i;:::-;;;;10825:142;;;;10977:15;10995:23;11007:10;10995:11;:23::i;:::-;10977:41;-1:-1:-1;11036:20:5;10977:41;11036:10;:20;:::i;:::-;11029:27;10660:403;-1:-1:-1;;;;;10660:403:5:o;2458:493::-;2530:19;:17;:19::i;:::-;2525:53;;2558:20;;-1:-1:-1;;;2558:20:5;;;;;;;;;;;2525:53;2593:33;39523:10:11;2620:5:5;;2593:12;:33::i;:::-;2588:62;;2635:15;;-1:-1:-1;;;2635:15:5;;;;;;;;;;;2588:62;39523:10:11;2665:24:5;;;;:10;:24;;;;;;203:1:7;;2665:28:5;;2692:1;2665:28;:::i;:::-;:55;2661:110;;;2741:30;;-1:-1:-1;;;2741:30:5;;;;;;;;;;;2661:110;299:3:7;2785:15:5;;2803:1;2785:19;;;;:::i;:::-;:35;2781:69;;;2829:21;;-1:-1:-1;;;2829:21:5;;;;;;;;;;;2781:69;39523:10:11;2861:24:5;;;;:10;:24;;;;;:26;;;;;;:::i;:::-;;;;-1:-1:-1;;2897:15:5;:17;;;:15;:17;;;:::i;:::-;;;;;;2925:19;2931:12;39523:10:11;;39437:103;23526:396;23695:31;23708:4;23714:2;23718:7;23695:12;:31::i;:::-;-1:-1:-1;;;;;23740:14:11;;;:19;23736:180;;23778:56;23809:4;23815:2;23819:7;23828:5;23778:30;:56::i;:::-;23773:143;;23861:40;;-1:-1:-1;;;23861:40:11;;;;;;;;;;;23773:143;23526:396;;;;:::o;4418:489:5:-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;4564:14:5;::::1;::::0;4560:77:::1;;4594:10;:32:::0;;-1:-1:-1;;4594:32:5::1;-1:-1:-1::0;;;;;4594:32:5;::::1;;::::0;;4560:77:::1;-1:-1:-1::0;;;;;4651:12:5;::::1;::::0;4647:144:::1;;4694:10;:20:::0;-1:-1:-1;;;;;4694:20:5;;::::1;4683:31:::0;;::::1;;4679:59;;4723:15;;-1:-1:-1::0;;;4723:15:5::1;;;;;;;;;;;4679:59;4752:10;:28:::0;;-1:-1:-1;;4752:28:5::1;-1:-1:-1::0;;;;;;;;4752:28:5;::::1;;;::::0;;4647:144:::1;4805:23:::0;;4801:100:::1;;4844:27:::0;:46;-1:-1:-1;;4418:489:5:o;9674:232::-;9760:7;9779:13;9795:25;9808:11;9795:12;:25::i;:::-;9779:41;;9830:15;9848:18;9860:5;9848:11;:18::i;:::-;9830:36;-1:-1:-1;9884:15:5;9830:36;9884:5;:15;:::i;12242:192::-;12329:13;12359:16;12367:7;12359;:16::i;:::-;12354:46;;12384:16;;-1:-1:-1;;;12384:16:5;;;;;;;;;;;12354:46;12418:9;12411:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12242:192;;;:::o;2215:138::-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;907:4:10;930:15;;;:7;:15;;;;;;370:18:::1;362:69;;;::::0;-1:-1:-1;;;362:69:10;;12940:2:13;362:69:10::1;::::0;::::1;12922:21:13::0;12979:2;12959:18;;;12952:30;13018:34;12998:18;;;12991:62;-1:-1:-1;;;13069:18:13;;;13062:36;13115:19;;362:69:10::1;;;;;;;;;442:13;448:6;-1:-1:-1::0;;;;;;626:15:10;;;;;:7;:15;;;;;:22;;-1:-1:-1;;626:22:10;644:4;626:22;;;578:77;442:13:::1;2299:47:5::2;1019:42;1131:2;2299:10;:47::i;:::-;1117:1:0::1;2215:138:5:o:0;12085:91::-;12129:7;12155:14;6752:12:11;;;6671:100;3763:471:5;8484:18;;-1:-1:-1;;;8484:18:5;;;;3815:57;;3850:22;;-1:-1:-1;;;3850:22:5;;;;;;;;;;;3815:57;3883:50;39523:10:11;3918:4:5;3925:7;3883:12;:50::i;:::-;3964:15;;3943:18;;-1:-1:-1;;;;;3964:15:5;:25;39523:10:11;3964:48:5;;-1:-1:-1;;;;;;3964:48:5;;;;;;;-1:-1:-1;;;;;13337:32:13;;;3964:48:5;;;13319:51:13;13386:18;;;13379:34;;;13292:18;;3964:48:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3943:69;;4023:23;4049:37;4070:15;;4068:17;;;;;:::i;:::-;;;;;-1:-1:-1;4049:18:5;:37::i;:::-;4130:15;;4023:63;;-1:-1:-1;4096:69:5;;-1:-1:-1;;;;;4130:15:5;4023:63;4096:17;:69::i;:::-;4199:10;4190:7;4181:46;4211:15;4181:46;;;;1391:25:13;;1379:2;1364:18;;1245:177;4181:46:5;;;;;;;;3805:429;;3763:471;:::o;6015:107::-;1094:13:0;:11;:13::i;:::-;6092:9:5::1;:23;6104:11:::0;6092:9;:23:::1;:::i;7636:313::-:0;7721:10;:20;7686:4;;-1:-1:-1;;;;;7721:20:5;:25;;;;:80;;-1:-1:-1;7781:10:5;:20;-1:-1:-1;;;;;7781:20:5;7762:15;:39;;7721:80;:119;;;;-1:-1:-1;7817:10:5;:18;-1:-1:-1;;;7817:18:5;;-1:-1:-1;;;;;7817:18:5;:23;;7721:119;:171;;;;-1:-1:-1;7874:10:5;:18;-1:-1:-1;;;7874:18:5;;-1:-1:-1;;;;;7874:18:5;7856:15;:36;7721:171;:221;;;;-1:-1:-1;;7908:27:5;;:34;;;7636:313::o;10279:128::-;10339:7;10365:35;10386:13;6164:12:11;;6148:13;;:28;;5894:317;2074:198:0;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2162:22:0;::::1;2154:73;;;::::0;-1:-1:-1;;;2154:73:0;;16019:2:13;2154:73:0::1;::::0;::::1;16001:21:13::0;16058:2;16038:18;;;16031:30;16097:34;16077:18;;;16070:62;-1:-1:-1;;;16148:18:13;;;16141:36;16194:19;;2154:73:0::1;15817:402:13::0;2154:73:0::1;2237:28;2256:8;2237:18;:28::i;11317:403:5:-:0;11434:7;11453:18;11487:9;11482:142;11506:8;11502:1;:12;11482:142;;;11535:13;11551:29;11564:15;11578:1;11564:11;:15;:::i;11551:29::-;11535:45;-1:-1:-1;11594:19:5;11535:45;11594:19;;:::i;:::-;;;11521:103;11516:3;;;;;:::i;:::-;;;;11482:142;;;;11634:15;11652:23;11664:10;11652:11;:23::i;:::-;11634:41;-1:-1:-1;11693:20:5;11634:41;11693:10;:20;:::i;8775:304::-;8883:4;8918:154;8954:5;;8918:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8977:27:5;;9032:25;;-1:-1:-1;;16373:2:13;16369:15;;;16365:53;9032:25:5;;;16353:66:13;8977:27:5;;-1:-1:-1;16435:12:13;;;-1:-1:-1;9032:25:5;;;;;;;;;;;;9022:36;;;;;;8918:18;:154::i;17693:277:11:-;17758:4;17845:13;;17835:7;:23;17793:151;;;;-1:-1:-1;;17895:26:11;;;;:17;:26;;;;;;-1:-1:-1;;;17895:44:11;:49;;17693:277::o;6128:156:5:-;6174:13;6190:27;6203:13;6164:12:11;;6148:13;;:28;;5894:317;6190:27:5;6174:43;;6227:23;6244:5;6227:16;:23::i;:::-;6261:16;6271:2;6275:1;6261:9;:16::i;6530:1642:4:-;6578:7;6601:1;6606;6601:6;6597:45;;-1:-1:-1;6630:1:4;;6530:1642;-1:-1:-1;6530:1642:4:o;6597:45::-;7321:14;7355:1;7344:7;7349:1;7344:4;:7::i;:::-;:12;;7338:1;:19;;7321:36;;7816:1;7805:6;7801:1;:10;;;;;:::i;:::-;;7792:6;:19;7791:26;;7782:35;;7865:1;7854:6;7850:1;:10;;;;;:::i;:::-;;7841:6;:19;7840:26;;7831:35;;7914:1;7903:6;7899:1;:10;;;;;:::i;:::-;;7890:6;:19;7889:26;;7880:35;;7963:1;7952:6;7948:1;:10;;;;;:::i;:::-;;7939:6;:19;7938:26;;7929:35;;8012:1;8001:6;7997:1;:10;;;;;:::i;:::-;;7988:6;:19;7987:26;;7978:35;;8061:1;8050:6;8046:1;:10;;;;;:::i;:::-;;8037:6;:19;8036:26;;8027:35;;8110:1;8099:6;8095:1;:10;;;;;:::i;:::-;;8086:6;:19;8085:26;;8076:35;;8132:23;8136:6;8148;8144:1;:10;;;;;:::i;:::-;;8132:3;:23::i;:::-;8125:30;6530:1642;-1:-1:-1;;;6530:1642:4:o;1157:194::-;1219:7;1316:6;;:28;;1339:1;1330:5;1334:1;1330;:5;:::i;:::-;1329:11;;;;:::i;:::-;:15;;1343:1;1329:15;:::i;:::-;1316:28;;;1325:1;1309:35;1157:194;-1:-1:-1;;;1157:194:4:o;12515:1249:11:-;12582:7;12616;12714:13;;12707:4;:20;12703:997;;;12751:14;12768:23;;;:17;:23;;;;;;;-1:-1:-1;;;12855:24:11;;:29;;12851:831;;13510:111;13517:6;13527:1;13517:11;13510:111;;-1:-1:-1;;;13587:6:11;13569:25;;;;:17;:25;;;;;;13510:111;;12851:831;12729:971;12703:997;13726:31;;-1:-1:-1;;;13726:31:11;;;;;;;;;;;1359:130:0;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;39523:10:11;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;17014:2:13;1414:68:0;;;16996:21:13;;;17033:18;;;17026:30;17092:34;17072:18;;;17065:62;17144:18;;1414:68:0;16812:356:13;33791:87:11;33850:21;33856:7;33865:5;33850;:21::i;7040:191:5:-;7100:15;7118:18;7130:5;7118:11;:18::i;:::-;7100:36;;7146:20;7158:7;7146:11;:20::i;:::-;39523:10:11;7177:47:5;7208:15;7216:7;7208:5;:15;:::i;:::-;7177:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7350:144;7423:15;7482:5;7458:20;944:3;7458:5;:20;:::i;:::-;7457:30;;;;:::i;2426:187:0:-;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;11979:159:11:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12106:24:11;;;;:17;:24;;;;;;12087:44;;-1:-1:-1;;;;;;;;;;;;;13967:41:11;;;;2004:3;14052:33;;;-1:-1:-1;;;;;14018:68:11;-1:-1:-1;;;14018:68:11;-1:-1:-1;;;14115:24:11;;:29;;-1:-1:-1;;;14096:48:11;;;;2513:3;14183:28;;;;-1:-1:-1;;;14154:58:11;-1:-1:-1;13858:361:11;25948:697;26126:88;;-1:-1:-1;;;26126:88:11;;26106:4;;-1:-1:-1;;;;;26126:45:11;;;;;:88;;39523:10;;26193:4;;26199:7;;26208:5;;26126:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26126:88:11;;;;;;;;-1:-1:-1;;26126:88:11;;;;;;;;;;;;:::i;:::-;;;26122:517;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26404:6;:13;26421:1;26404:18;26400:229;;26449:40;;-1:-1:-1;;;26449:40:11;;;;;;;;;;;26400:229;26589:6;26583:13;26574:6;26570:2;26566:15;26559:38;26122:517;-1:-1:-1;;;;;;26282:64:11;-1:-1:-1;;;26282:64:11;;-1:-1:-1;25948:697:11;;;;;;:::o;6290:368:5:-;6359:21;6383:13;6164:12:11;;6148:13;;:28;;5894:317;6383:13:5;6359:37;-1:-1:-1;6406:18:5;;6435:144;6459:8;6455:1;:12;6435:144;;;6488:13;6504:31;6517:17;6533:1;6517:13;:17;:::i;6504:31::-;6488:47;-1:-1:-1;6549:19:5;6488:47;6549:19;;:::i;:::-;;;6474:105;6469:3;;;;;:::i;:::-;;;;6435:144;;;;6589:28;6606:10;6589:16;:28::i;:::-;6628:23;6638:2;6642:8;6628:9;:23::i;2647:312:1:-;2761:6;2736:21;:31;;2728:73;;;;-1:-1:-1;;;2728:73:1;;18123:2:13;2728:73:1;;;18105:21:13;18162:2;18142:18;;;18135:30;18201:31;18181:18;;;18174:59;18250:18;;2728:73:1;17921:353:13;2728:73:1;2813:12;2831:9;-1:-1:-1;;;;;2831:14:1;2853:6;2831:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2812:52;;;2882:7;2874:78;;;;-1:-1:-1;;;2874:78:1;;18691:2:13;2874:78:1;;;18673:21:13;18730:2;18710:18;;;18703:30;18769:34;18749:18;;;18742:62;18840:28;18820:18;;;18813:56;18886:19;;2874:78:1;18489:422:13;1156:154:3;1247:4;1299;1270:25;1283:5;1290:4;1270:12;:25::i;:::-;:33;;1156:154;-1:-1:-1;;;;1156:154:3:o;6664:370:5:-;6724:15;6742:18;6754:5;6742:11;:18::i;:::-;6724:36;-1:-1:-1;6770:20:5;6793:15;6724:36;6793:5;:15;:::i;:::-;6770:38;;6835:12;6823:9;:24;6819:56;;;6856:19;;-1:-1:-1;;;6856:19:5;;;;;;;;;;;6819:56;6886:20;6898:7;6886:11;:20::i;:::-;6933:12;6921:9;:24;6917:111;;;39523:10:11;6961:56:5;6992:24;7004:12;6992:9;:24;:::i;:::-;6961:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33423:110:11;33499:27;33509:2;33513:8;33499:27;;;;;;;;;;;;:9;:27::i;8633:983:4:-;8685:7;;8769:3;8760:12;;;:16;8756:99;;8806:3;8796:13;;;;8827;8756:99;8881:2;8872:11;;;:15;8868:96;;8917:2;8907:12;;;;8937;8868:96;8990:2;8981:11;;;:15;8977:96;;9026:2;9016:12;;;;9046;8977:96;9099:2;9090:11;;;:15;9086:96;;9135:2;9125:12;;;;9155;9086:96;9208:1;9199:10;;;:14;9195:93;;9243:1;9233:11;;;;9262;9195:93;9314:1;9305:10;;;:14;9301:93;;9349:1;9339:11;;;;9368;9301:93;9420:1;9411:10;;;:14;9407:93;;9455:1;9445:11;;;;9474;9407:93;9526:1;9517:10;;;:14;9513:64;;9561:1;9551:11;9603:6;8633:983;-1:-1:-1;;8633:983:4:o;588:104::-;646:7;676:1;672;:5;:13;;684:1;672:13;;;-1:-1:-1;680:1:4;;588:104;-1:-1:-1;588:104:4:o;34095:3015:11:-;34174:27;34204;34223:7;34204:18;:27::i;:::-;34174:57;-1:-1:-1;34174:57:11;34242:12;;34362:35;34389:7;18927:27;19036:24;;;:15;:24;;;;;19260:26;;19036:24;;18828:474;34362:35;34305:92;;;;34412:13;34408:312;;;34531:68;34556:15;34573:4;39523:10;34579:19;39437:103;34531:68;34526:183;;34622:43;34639:4;39523:10;17282:162;:::i;34622:43::-;34617:92;;34674:35;;-1:-1:-1;;;34674:35:11;;;;;;;;;;;34617:92;34870:15;34867:157;;;35008:1;34987:19;34980:30;34867:157;-1:-1:-1;;;;;35613:24:11;;;;;;:18;:24;;;;;:60;;35641:32;35613:60;;;14703:11;14678:23;14674:41;14661:63;-1:-1:-1;;;14661:63:11;35904:26;;;;:17;:26;;;;;:202;;;;-1:-1:-1;;;36223:47:11;;:52;;36219:617;;36327:1;36317:11;;36295:19;36448:30;;;:17;:30;;;;;;:35;;36444:378;;36584:13;;36569:11;:28;36565:239;;36729:30;;;;:17;:30;;;;;:52;;;36565:239;36277:559;36219:617;36861:35;;36888:7;;36884:1;;-1:-1:-1;;;;;36861:35:11;;;-1:-1:-1;;;;;;;;;;;36861:35:11;36884:1;;36861:35;-1:-1:-1;;37079:12:11;:14;;;;;;-1:-1:-1;;;;34095:3015:11:o;7237:107:5:-;7302:16;;7294:43;;-1:-1:-1;;;;;7302:16:5;;;;7294:43;;;;;7329:7;;7302:16;7294:43;7302:16;7294:43;7329:7;7302:16;7294:43;;;;;;;;;;;;;;;;;;;1934:290:3;2017:7;2059:4;2017:7;2073:116;2097:5;:12;2093:1;:16;2073:116;;;2145:33;2155:12;2169:5;2175:1;2169:8;;;;;;;;:::i;:::-;;;;;;;2145:9;:33::i;:::-;2130:48;-1:-1:-1;2111:3:3;;;;:::i;:::-;;;;2073:116;;;-1:-1:-1;2205:12:3;1934:290;-1:-1:-1;;;1934:290:3:o;32675:669:11:-;32801:19;32807:2;32811:8;32801:5;:19::i;:::-;-1:-1:-1;;;;;32859:14:11;;;:19;32855:473;;32912:13;;32959:14;;;32991:229;33021:62;33060:1;33064:2;33068:7;;;;;;33077:5;33021:30;:62::i;:::-;33016:165;;33118:40;;-1:-1:-1;;;33118:40:11;;;;;;;;;;;33016:165;33215:3;33207:5;:11;32991:229;;33300:3;33283:13;;:20;33279:34;;33305:8;;;33279:34;32880:448;;32675:669;;;:::o;9205:147:3:-;9268:7;9298:1;9294;:5;:51;;9426:13;9517:15;;;9552:4;9545:15;;;9598:4;9582:21;;1316:28:4;;9294:51:3;9426:13;9517:15;;;9552:4;9545:15;;;9598:4;9582:21;;9302:20;9358:261;27091:2902:11;27186:13;;27163:20;27213:13;;;27209:44;;27235:18;;-1:-1:-1;;;27235:18:11;;;;;;;;;;;27209:44;-1:-1:-1;;;;;27728:22:11;;;;;;:18;:22;;;;1495:2;27728:22;;;:71;;27766:32;27754:45;;27728:71;;;28035:31;;;:17;:31;;;;;-1:-1:-1;15123:15:11;;15097:24;15093:46;14703:11;14678:23;14674:41;14671:52;14661:63;;28035:170;;28264:23;;;;28035:31;;27728:22;;-1:-1:-1;;;;;;;;;;;27728:22:11;;28872:328;29520:1;29506:12;29502:20;29461:339;29560:3;29551:7;29548:16;29461:339;;29774:7;29764:8;29761:1;-1:-1:-1;;;;;;;;;;;29731:1:11;29728;29723:59;29612:1;29599:15;29461:339;;;29465:75;29831:8;29843:1;29831:13;29827:45;;29853:19;;-1:-1:-1;;;29853:19:11;;;;;;;;;;;29827:45;29887:13;:19;-1:-1:-1;22758:187:11;;;:::o;206:131:13:-;-1:-1:-1;;;;;;280:32:13;;270:43;;260:71;;327:1;324;317:12;342:245;400:6;453:2;441:9;432:7;428:23;424:32;421:52;;;469:1;466;459:12;421:52;508:9;495:23;527:30;551:5;527:30;:::i;592:423::-;634:3;672:5;666:12;699:6;694:3;687:19;724:1;734:162;748:6;745:1;742:13;734:162;;;810:4;866:13;;;862:22;;856:29;838:11;;;834:20;;827:59;763:12;734:162;;;738:3;941:1;934:4;925:6;920:3;916:16;912:27;905:38;1004:4;997:2;993:7;988:2;980:6;976:15;972:29;967:3;963:39;959:50;952:57;;;592:423;;;;:::o;1020:220::-;1169:2;1158:9;1151:21;1132:4;1189:45;1230:2;1219:9;1215:18;1207:6;1189:45;:::i;1635:180::-;1694:6;1747:2;1735:9;1726:7;1722:23;1718:32;1715:52;;;1763:1;1760;1753:12;1715:52;-1:-1:-1;1786:23:13;;1635:180;-1:-1:-1;1635:180:13:o;1820:131::-;-1:-1:-1;;;;;1895:31:13;;1885:42;;1875:70;;1941:1;1938;1931:12;1956:315;2024:6;2032;2085:2;2073:9;2064:7;2060:23;2056:32;2053:52;;;2101:1;2098;2091:12;2053:52;2140:9;2127:23;2159:31;2184:5;2159:31;:::i;:::-;2209:5;2261:2;2246:18;;;;2233:32;;-1:-1:-1;;;1956:315:13:o;2276:456::-;2353:6;2361;2369;2422:2;2410:9;2401:7;2397:23;2393:32;2390:52;;;2438:1;2435;2428:12;2390:52;2477:9;2464:23;2496:31;2521:5;2496:31;:::i;:::-;2546:5;-1:-1:-1;2603:2:13;2588:18;;2575:32;2616:33;2575:32;2616:33;:::i;:::-;2276:456;;2668:7;;-1:-1:-1;;;2722:2:13;2707:18;;;;2694:32;;2276:456::o;2737:272::-;2821:6;2874:2;2862:9;2853:7;2849:23;2845:32;2842:52;;;2890:1;2887;2880:12;2842:52;2929:9;2916:23;2948:31;2973:5;2948:31;:::i;3266:171::-;3333:20;;-1:-1:-1;;;;;3382:30:13;;3372:41;;3362:69;;3427:1;3424;3417:12;3362:69;3266:171;;;:::o;3442:184::-;3500:6;3553:2;3541:9;3532:7;3528:23;3524:32;3521:52;;;3569:1;3566;3559:12;3521:52;3592:28;3610:9;3592:28;:::i;3864:160::-;3929:20;;3985:13;;3978:21;3968:32;;3958:60;;4014:1;4011;4004:12;4029:180;4085:6;4138:2;4126:9;4117:7;4113:23;4109:32;4106:52;;;4154:1;4151;4144:12;4106:52;4177:26;4193:9;4177:26;:::i;4214:632::-;4385:2;4437:21;;;4507:13;;4410:18;;;4529:22;;;4356:4;;4385:2;4608:15;;;;4582:2;4567:18;;;4356:4;4651:169;4665:6;4662:1;4659:13;4651:169;;;4726:13;;4714:26;;4795:15;;;;4760:12;;;;4687:1;4680:9;4651:169;;4851:315;4916:6;4924;4977:2;4965:9;4956:7;4952:23;4948:32;4945:52;;;4993:1;4990;4983:12;4945:52;5032:9;5019:23;5051:31;5076:5;5051:31;:::i;:::-;5101:5;-1:-1:-1;5125:35:13;5156:2;5141:18;;5125:35;:::i;:::-;5115:45;;4851:315;;;;;:::o;5376:248::-;5444:6;5452;5505:2;5493:9;5484:7;5480:23;5476:32;5473:52;;;5521:1;5518;5511:12;5473:52;-1:-1:-1;;5544:23:13;;;5614:2;5599:18;;;5586:32;;-1:-1:-1;5376:248:13:o;5629:367::-;5692:8;5702:6;5756:3;5749:4;5741:6;5737:17;5733:27;5723:55;;5774:1;5771;5764:12;5723:55;-1:-1:-1;5797:20:13;;-1:-1:-1;;;;;5829:30:13;;5826:50;;;5872:1;5869;5862:12;5826:50;5909:4;5901:6;5897:17;5885:29;;5969:3;5962:4;5952:6;5949:1;5945:14;5937:6;5933:27;5929:38;5926:47;5923:67;;;5986:1;5983;5976:12;5923:67;5629:367;;;;;:::o;6001:437::-;6087:6;6095;6148:2;6136:9;6127:7;6123:23;6119:32;6116:52;;;6164:1;6161;6154:12;6116:52;6204:9;6191:23;-1:-1:-1;;;;;6229:6:13;6226:30;6223:50;;;6269:1;6266;6259:12;6223:50;6308:70;6370:7;6361:6;6350:9;6346:22;6308:70;:::i;:::-;6397:8;;6282:96;;-1:-1:-1;6001:437:13;-1:-1:-1;;;;6001:437:13:o;6443:127::-;6504:10;6499:3;6495:20;6492:1;6485:31;6535:4;6532:1;6525:15;6559:4;6556:1;6549:15;6575:631;6639:5;-1:-1:-1;;;;;6710:2:13;6702:6;6699:14;6696:40;;;6716:18;;:::i;:::-;6791:2;6785:9;6759:2;6845:15;;-1:-1:-1;;6841:24:13;;;6867:2;6837:33;6833:42;6821:55;;;6891:18;;;6911:22;;;6888:46;6885:72;;;6937:18;;:::i;:::-;6977:10;6973:2;6966:22;7006:6;6997:15;;7036:6;7028;7021:22;7076:3;7067:6;7062:3;7058:16;7055:25;7052:45;;;7093:1;7090;7083:12;7052:45;7143:6;7138:3;7131:4;7123:6;7119:17;7106:44;7198:1;7191:4;7182:6;7174;7170:19;7166:30;7159:41;;;;6575:631;;;;;:::o;7211:794::-;7306:6;7314;7322;7330;7383:3;7371:9;7362:7;7358:23;7354:33;7351:53;;;7400:1;7397;7390:12;7351:53;7439:9;7426:23;7458:31;7483:5;7458:31;:::i;:::-;7508:5;-1:-1:-1;7565:2:13;7550:18;;7537:32;7578:33;7537:32;7578:33;:::i;:::-;7630:7;-1:-1:-1;7684:2:13;7669:18;;7656:32;;-1:-1:-1;7739:2:13;7724:18;;7711:32;-1:-1:-1;;;;;7755:30:13;;7752:50;;;7798:1;7795;7788:12;7752:50;7821:22;;7874:4;7866:13;;7862:27;-1:-1:-1;7852:55:13;;7903:1;7900;7893:12;7852:55;7926:73;7991:7;7986:2;7973:16;7968:2;7964;7960:11;7926:73;:::i;:::-;7916:83;;;7211:794;;;;;;;:::o;8010:324::-;8085:6;8093;8101;8154:2;8142:9;8133:7;8129:23;8125:32;8122:52;;;8170:1;8167;8160:12;8122:52;8193:28;8211:9;8193:28;:::i;:::-;8183:38;;8240:37;8273:2;8262:9;8258:18;8240:37;:::i;:::-;8230:47;;8324:2;8313:9;8309:18;8296:32;8286:42;;8010:324;;;;;:::o;8339:450::-;8408:6;8461:2;8449:9;8440:7;8436:23;8432:32;8429:52;;;8477:1;8474;8467:12;8429:52;8517:9;8504:23;-1:-1:-1;;;;;8542:6:13;8539:30;8536:50;;;8582:1;8579;8572:12;8536:50;8605:22;;8658:4;8650:13;;8646:27;-1:-1:-1;8636:55:13;;8687:1;8684;8677:12;8636:55;8710:73;8775:7;8770:2;8757:16;8752:2;8748;8744:11;8710:73;:::i;9169:388::-;9237:6;9245;9298:2;9286:9;9277:7;9273:23;9269:32;9266:52;;;9314:1;9311;9304:12;9266:52;9353:9;9340:23;9372:31;9397:5;9372:31;:::i;:::-;9422:5;-1:-1:-1;9479:2:13;9464:18;;9451:32;9492:33;9451:32;9492:33;:::i;:::-;9544:7;9534:17;;;9169:388;;;;;:::o;9562:572::-;9657:6;9665;9673;9726:2;9714:9;9705:7;9701:23;9697:32;9694:52;;;9742:1;9739;9732:12;9694:52;9781:9;9768:23;9800:31;9825:5;9800:31;:::i;:::-;9850:5;-1:-1:-1;9906:2:13;9891:18;;9878:32;-1:-1:-1;;;;;9922:30:13;;9919:50;;;9965:1;9962;9955:12;9919:50;10004:70;10066:7;10057:6;10046:9;10042:22;10004:70;:::i;:::-;9562:572;;10093:8;;-1:-1:-1;9978:96:13;;-1:-1:-1;;;;9562:572:13:o;10139:380::-;10218:1;10214:12;;;;10261;;;10282:61;;10336:4;10328:6;10324:17;10314:27;;10282:61;10389:2;10381:6;10378:14;10358:18;10355:38;10352:161;;10435:10;10430:3;10426:20;10423:1;10416:31;10470:4;10467:1;10460:15;10498:4;10495:1;10488:15;10352:161;;10139:380;;;:::o;10524:127::-;10585:10;10580:3;10576:20;10573:1;10566:31;10616:4;10613:1;10606:15;10640:4;10637:1;10630:15;10656:422;10745:1;10788:5;10745:1;10802:270;10823:7;10813:8;10810:21;10802:270;;;10882:4;10878:1;10874:6;10870:17;10864:4;10861:27;10858:53;;;10891:18;;:::i;:::-;10941:7;10931:8;10927:22;10924:55;;;10961:16;;;;10924:55;11040:22;;;;11000:15;;;;10802:270;;;10806:3;10656:422;;;;;:::o;11083:806::-;11132:5;11162:8;11152:80;;-1:-1:-1;11203:1:13;11217:5;;11152:80;11251:4;11241:76;;-1:-1:-1;11288:1:13;11302:5;;11241:76;11333:4;11351:1;11346:59;;;;11419:1;11414:130;;;;11326:218;;11346:59;11376:1;11367:10;;11390:5;;;11414:130;11451:3;11441:8;11438:17;11435:43;;;11458:18;;:::i;:::-;-1:-1:-1;;11514:1:13;11500:16;;11529:5;;11326:218;;11628:2;11618:8;11615:16;11609:3;11603:4;11600:13;11596:36;11590:2;11580:8;11577:16;11572:2;11566:4;11563:12;11559:35;11556:77;11553:159;;;-1:-1:-1;11665:19:13;;;11697:5;;11553:159;11744:34;11769:8;11763:4;11744:34;:::i;:::-;11814:6;11810:1;11806:6;11802:19;11793:7;11790:32;11787:58;;;11825:18;;:::i;:::-;11863:20;;11083:806;-1:-1:-1;;;11083:806:13:o;11894:131::-;11954:5;11983:36;12010:8;12004:4;11983:36;:::i;12030:168::-;12103:9;;;12134;;12151:15;;;12145:22;;12131:37;12121:71;;12172:18;;:::i;12203:125::-;12268:9;;;12289:10;;;12286:36;;;12302:18;;:::i;12333:135::-;12372:3;12393:17;;;12390:43;;12413:18;;:::i;:::-;-1:-1:-1;12460:1:13;12449:13;;12333:135::o;12473:127::-;12534:10;12529:3;12525:20;12522:1;12515:31;12565:4;12562:1;12555:15;12589:4;12586:1;12579:15;12605:128;12672:9;;;12693:11;;;12690:37;;;12707:18;;:::i;13424:184::-;13494:6;13547:2;13535:9;13526:7;13522:23;13518:32;13515:52;;;13563:1;13560;13553:12;13515:52;-1:-1:-1;13586:16:13;;13424:184;-1:-1:-1;13424:184:13:o;13739:545::-;13841:2;13836:3;13833:11;13830:448;;;13877:1;13902:5;13898:2;13891:17;13947:4;13943:2;13933:19;14017:2;14005:10;14001:19;13998:1;13994:27;13988:4;13984:38;14053:4;14041:10;14038:20;14035:47;;;-1:-1:-1;14076:4:13;14035:47;14131:2;14126:3;14122:12;14119:1;14115:20;14109:4;14105:31;14095:41;;14186:82;14204:2;14197:5;14194:13;14186:82;;;14249:17;;;14230:1;14219:13;14186:82;;14460:1352;14586:3;14580:10;-1:-1:-1;;;;;14605:6:13;14602:30;14599:56;;;14635:18;;:::i;:::-;14664:97;14754:6;14714:38;14746:4;14740:11;14714:38;:::i;:::-;14708:4;14664:97;:::i;:::-;14816:4;;14880:2;14869:14;;14897:1;14892:663;;;;15599:1;15616:6;15613:89;;;-1:-1:-1;15668:19:13;;;15662:26;15613:89;-1:-1:-1;;14417:1:13;14413:11;;;14409:24;14405:29;14395:40;14441:1;14437:11;;;14392:57;15715:81;;14862:944;;14892:663;13686:1;13679:14;;;13723:4;13710:18;;-1:-1:-1;;14928:20:13;;;15046:236;15060:7;15057:1;15054:14;15046:236;;;15149:19;;;15143:26;15128:42;;15241:27;;;;15209:1;15197:14;;;;15076:19;;15046:236;;;15050:3;15310:6;15301:7;15298:19;15295:201;;;15371:19;;;15365:26;-1:-1:-1;;15454:1:13;15450:14;;;15466:3;15446:24;15442:37;15438:42;15423:58;15408:74;;15295:201;-1:-1:-1;;;;;15542:1:13;15526:14;;;15522:22;15509:36;;-1:-1:-1;14460:1352:13:o;16458:127::-;16519:10;16514:3;16510:20;16507:1;16500:31;16550:4;16547:1;16540:15;16574:4;16571:1;16564:15;16590:217;16630:1;16656;16646:132;;16700:10;16695:3;16691:20;16688:1;16681:31;16735:4;16732:1;16725:15;16763:4;16760:1;16753:15;16646:132;-1:-1:-1;16792:9:13;;16590:217::o;17173:489::-;-1:-1:-1;;;;;17442:15:13;;;17424:34;;17494:15;;17489:2;17474:18;;17467:43;17541:2;17526:18;;17519:34;;;17589:3;17584:2;17569:18;;17562:31;;;17367:4;;17610:46;;17636:19;;17628:6;17610:46;:::i;:::-;17602:54;17173:489;-1:-1:-1;;;;;;17173:489:13:o;17667:249::-;17736:6;17789:2;17777:9;17768:7;17764:23;17760:32;17757:52;;;17805:1;17802;17795:12;17757:52;17837:9;17831:16;17856:30;17880:5;17856:30;:::i

ipfs://10789f2882f53e24776f52aa6bfe23c8616381bf5777eddb74f79f5ec23e39d5