Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(    - function functionCallWithValue(    - function functionCallWithValue(    - function functionStaticCall(address t ...    - function functionStaticCall(    - function functionDelegateCall(address ...    - function functionDelegateCall(    - function verifyCallResult( library SafeERC20    - function safeTransfer(    - function safeTransferFrom(    - function safeApprove(    - function safeIncreaseAllowance(    - function safeDecreaseAllowance(    - function _callOptionalReturn(IERC20 t ... interface IERC165    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(    - function transferFrom(    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function safeTransferFrom( interface IERC721Receiver    - function onERC721Received( interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId) interface IERC721Enumerable is IERC72 ...    - function totalSupply()    - function tokenOfOwnerByIndex(address ...    - function tokenByIndex(uint256 index) library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function supportsInterface(bytes4 int ...  contract ERC721A is Context, ERC16 ...    - function _startTokenId()    - function totalSupply()    - function _totalMinted()    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function _numberMinted(address owner)    - function _numberBurned(address owner)    - function _getAux(address owner)    - function _setAux(address owner, uint6 ...    - function _ownershipOf(uint256 tokenId ...    - function ownerOf(uint256 tokenId)    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _exists(uint256 tokenId)    - function _safeMint(address to, uint25 ...    - function _safeMint(    - function _mint(    - function _transfer(    - function _burn(uint256 tokenId)    - function _burn(uint256 tokenId, bool ...    - function _approve(    - function _checkContractOnERC721Receiv ...    - function _beforeTokenTransfers(    - function _afterTokenTransfers(  contract BagheadBros is ERC721A, O ... *    - function publicMint(uint qty)    - function _baseURI()    - function exists(uint256 tokenId)    - function tokenURI(uint tokenId)    - function setBaseURI(string memory bas ...    - function giftMint(address recipient, ...    - function airDrop(address[] memory use ...    - function pause(bool _state)    - function withdraw()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-10-01
*/

// File: contracts/BagheadBros.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;
    }
}


// File @openzeppelin/contracts/access/[email protected]



pragma solidity ^0.8.0;

/**
 * @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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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);
    }
}


// File @openzeppelin/contracts/security/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.5.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
     * ====
     *
     * [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://diligence.consensys.net/posts/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.5.11/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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;


/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @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
    ) external;

    /**
     * @dev Transfers `tokenId` token 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;

    /**
     * @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;

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

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

    /**
     * @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 calldata data
    ) external;
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @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);
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}



// props to chiru for 721A
pragma solidity ^0.8.4;



error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _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 _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

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

  
 
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
        
    }
    
    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 1;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

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

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

    /**
     * Sets the auxillary 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 {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    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, tokenId.toString())) : '';
    }

    /**
     * @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, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

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

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSender()) revert ApproveToCaller();

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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 (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, 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.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @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.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        
        uint256 startTokenId = _currentIndex;
        
        if (quantity == 0) revert MintZeroQuantity();
          
        _beforeTokenTransfers(address(0), to, startTokenId, quantity);
       
        
        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // 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 {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }
 
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is 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 {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // 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 {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

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

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

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

    /**
     * @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 {}
}
/**/
pragma solidity ^0.8.0;

contract BagheadBros is ERC721A, Ownable {
    
    using Strings for uint;
    
//Standard Variables
    
    uint public cost = 0;
    uint private constant totalBagheads = 1987;
    uint private constant maxPerMint = 5;
    bool paused = true;

    

    constructor(
    ) ERC721A("BagHeadBros", "BHB")payable{
        _mint(msg.sender, 1,"",true);
    }

  
//Public Functions



    function publicMint(uint qty) external payable
    
    {
        uint tm = _totalMinted();
        require(msg.sender == tx.origin, "no bots asshole");
        require(qty<6,"10 max bruh");
        require(tm + qty < 1988, "SOLD OUT!");
        
                                  
                _mint(msg.sender, qty,"",true);       
    }
 
//Metadata Functions
    string private _baseTokenURI;

    function _baseURI() internal view virtual override returns (string memory) 
    {
        return _baseTokenURI;
    }

    function exists(uint256 tokenId) public view returns (bool) 
    {
        return _exists(tokenId);
    }

    function tokenURI(uint tokenId) public view virtual override returns (string memory) 
    {
      
    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), ".json"))
        : "";
    }

//OnlyOwner Functions
    
    function setBaseURI(string memory baseURI) external onlyOwner 
    {
        _baseTokenURI = baseURI;
    }

    
    function giftMint(address recipient, uint qty) external onlyOwner 
    {
        require(_totalMinted() + qty <10001, "SOLD OUT!");

                _mint(recipient, qty, '', true);
    }

    function airDrop(address[] memory users) external onlyOwner 
    {
        for (uint256 i; i < users.length; i++) 
        {
            _mint(users[i], 1, '', true);
        }
    }

    function pause(bool _state) public onlyOwner() 
    {
        paused = _state;
    }


    function withdraw() public payable onlyOwner 
    {
        (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
        require(success);
    }

    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","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":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address[]","name":"users","type":"address[]"}],"name":"airDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"giftMint","outputs":[],"stateMutability":"nonpayable","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":"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":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","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":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","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":[],"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":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

6000600955600a805460ff19166001179055600b60808181526a4261674865616442726f7360a81b60a0908152610100604052600360c09081526221242160e91b60e05291926200005391600291620003a5565b50805162000069906003906020840190620003a5565b50506001600055506200007c33620000a7565b620000a1336001604051806020016040528060008152506001620000f960201b60201c565b62000536565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054836200011b5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546001600160801b031981166001600160401b038083168c018116918217680100000000000000006001600160401b031990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015620001d45750620001d4876001600160a01b03166200029560201b62000e4e1760201c565b1562000254575b60405182906001600160a01b038916906000906000805160206200224f833981519152908290a460018201916200021890600090899088620002a4565b62000236576040516368d2bf6b60e11b815260040160405180910390fd5b80821415620001db5782600054146200024e57600080fd5b6200028a565b5b6040516001830192906001600160a01b038916906000906000805160206200224f833981519152908290a48082141562000255575b506000555050505050565b6001600160a01b03163b151590565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290620002db9033908990889088906004016200047e565b602060405180830381600087803b158015620002f657600080fd5b505af192505050801562000329575060408051601f3d908101601f1916820190925262000326918101906200044b565b60015b62000388573d8080156200035a576040519150601f19603f3d011682016040523d82523d6000602084013e6200035f565b606091505b50805162000380576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050949350505050565b828054620003b390620004f9565b90600052602060002090601f016020900481019282620003d7576000855562000422565b82601f10620003f257805160ff191683800117855562000422565b8280016001018555821562000422579182015b828111156200042257825182559160200191906001019062000405565b506200043092915062000434565b5090565b5b8082111562000430576000815560010162000435565b6000602082840312156200045e57600080fd5b81516001600160e01b0319811681146200047757600080fd5b9392505050565b600060018060a01b038087168352602081871681850152856040850152608060608501528451915081608085015260005b82811015620004cd5785810182015185820160a001528101620004af565b82811115620004e057600060a084870101525b5050601f01601f19169190910160a00195945050505050565b600181811c908216806200050e57607f821691505b602082108114156200053057634e487b7160e01b600052602260045260246000fd5b50919050565b611d0980620005466000396000f3fe6080604052600436106101955760003560e01c806345bf9b15116100e15780638da5cb5b1161008a578063b88d4fde11610064578063b88d4fde1461044f578063c87b56dd1461046f578063e985e9c51461048f578063f2fde38b146104d857600080fd5b80638da5cb5b146103fc57806395d89b411461041a578063a22cb4651461042f57600080fd5b80636352211e116100bb5780636352211e1461038757806370a08231146103a7578063715018a6146103e757600080fd5b806345bf9b15146103275780634f558e791461034757806355f804b31461036757600080fd5b806313faede6116101435780632db115441161011d5780632db11544146102ec5780633ccfd60b146102ff57806342842e0e1461030757600080fd5b806313faede61461028b57806318160ddd146102af57806323b872dd146102cc57600080fd5b806306fdde031161017457806306fdde0314610211578063081812fc14610233578063095ea7b31461026b57600080fd5b8062b6849f1461019a57806301ffc9a7146101bc57806302329a29146101f1575b600080fd5b3480156101a657600080fd5b506101ba6101b536600461191e565b6104f8565b005b3480156101c857600080fd5b506101dc6101d73660046119ed565b6105af565b60405190151581526020015b60405180910390f35b3480156101fd57600080fd5b506101ba61020c3660046119d2565b61064c565b34801561021d57600080fd5b506102266106b9565b6040516101e89190611b48565b34801561023f57600080fd5b5061025361024e366004611a70565b61074b565b6040516001600160a01b0390911681526020016101e8565b34801561027757600080fd5b506101ba6102863660046118f4565b6107a8565b34801561029757600080fd5b506102a160095481565b6040519081526020016101e8565b3480156102bb57600080fd5b5060015460005403600019016102a1565b3480156102d857600080fd5b506101ba6102e7366004611812565b610868565b6101ba6102fa366004611a70565b610873565b6101ba61097b565b34801561031357600080fd5b506101ba610322366004611812565b610a2d565b34801561033357600080fd5b506101ba6103423660046118f4565b610a48565b34801561035357600080fd5b506101dc610362366004611a70565b610b12565b34801561037357600080fd5b506101ba610382366004611a27565b610b1d565b34801561039357600080fd5b506102536103a2366004611a70565b610b8a565b3480156103b357600080fd5b506102a16103c23660046117c4565b6001600160a01b031660009081526005602052604090205467ffffffffffffffff1690565b3480156103f357600080fd5b506101ba610b9c565b34801561040857600080fd5b506008546001600160a01b0316610253565b34801561042657600080fd5b50610226610c02565b34801561043b57600080fd5b506101ba61044a3660046118ca565b610c11565b34801561045b57600080fd5b506101ba61046a36600461184e565b610cc0565b34801561047b57600080fd5b5061022661048a366004611a70565b610d11565b34801561049b57600080fd5b506101dc6104aa3660046117df565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b3480156104e457600080fd5b506101ba6104f33660046117c4565b610d6f565b6008546001600160a01b031633146105575760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064015b60405180910390fd5b60005b81518110156105ab5761059982828151811061057857610578611c91565b60200260200101516001604051806020016040528060008152506001610e5d565b806105a381611c36565b91505061055a565b5050565b60006001600160e01b031982167f80ac58cd00000000000000000000000000000000000000000000000000000000148061061257506001600160e01b031982167f5b5e139f00000000000000000000000000000000000000000000000000000000145b8061064657507f01ffc9a7000000000000000000000000000000000000000000000000000000006001600160e01b03198316145b92915050565b6008546001600160a01b031633146106a65760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b600a805460ff1916911515919091179055565b6060600280546106c890611bfb565b80601f01602080910402602001604051908101604052809291908181526020018280546106f490611bfb565b80156107415780601f1061071657610100808354040283529160200191610741565b820191906000526020600020905b81548152906001019060200180831161072457829003601f168201915b5050505050905090565b600061075682611033565b61078c576040517fcf4700e400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b60006107b382610b8a565b9050806001600160a01b0316836001600160a01b03161415610801576040517f943f7b8c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b336001600160a01b03821614801590610821575061081f81336104aa565b155b15610858576040517fcfb3b94200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61086383838361106c565b505050565b6108638383836110d5565b600054600019013233146108c95760405162461bcd60e51b815260206004820152600f60248201527f6e6f20626f747320617373686f6c650000000000000000000000000000000000604482015260640161054e565b600682106109195760405162461bcd60e51b815260206004820152600b60248201527f3130206d61782062727568000000000000000000000000000000000000000000604482015260640161054e565b6107c46109268383611b8c565b1061095f5760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b604482015260640161054e565b6105ab3383604051806020016040528060008152506001610e5d565b6008546001600160a01b031633146109d55760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b604051600090339047908381818185875af1925050503d8060008114610a17576040519150601f19603f3d011682016040523d82523d6000602084013e610a1c565b606091505b5050905080610a2a57600080fd5b50565b61086383838360405180602001604052806000815250610cc0565b6008546001600160a01b03163314610aa25760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b61271181610ab36000546000190190565b610abd9190611b8c565b10610af65760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b604482015260640161054e565b6105ab8282604051806020016040528060008152506001610e5d565b600061064682611033565b6008546001600160a01b03163314610b775760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b80516105ab90600b9060208401906116a7565b6000610b95826112cd565b5192915050565b6008546001600160a01b03163314610bf65760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b610c00600061140f565b565b6060600380546106c890611bfb565b6001600160a01b038216331415610c54576040517fb06307db00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b610ccb8484846110d5565b6001600160a01b0383163b15158015610ced5750610ceb8484848461146e565b155b15610d0b576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b60606000610d1d611566565b90506000815111610d3d5760405180602001604052806000815250610d68565b80610d4784611575565b604051602001610d58929190611ab5565b6040516020818303038152906040525b9392505050565b6008546001600160a01b03163314610dc95760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161054e565b6001600160a01b038116610e455760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f6464726573730000000000000000000000000000000000000000000000000000606482015260840161054e565b610a2a8161140f565b6001600160a01b03163b151590565b60005483610e97576040517fb562e8dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080547fffffffffffffffffffffffffffffffff00000000000000000000000000000000811667ffffffffffffffff8083168c0181169182176801000000000000000067ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015610f5857506001600160a01b0387163b15155b15610fe1575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4610fa9600088848060010195508861146e565b610fc6576040516368d2bf6b60e11b815260040160405180910390fd5b80821415610f5e578260005414610fdc57600080fd5b611027565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a480821415610fe2575b506000555b5050505050565b600081600111158015611047575060005482105b8015610646575050600090815260046020526040902054600160e01b900460ff161590565b600082815260066020526040808220805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b60006110e0826112cd565b9050836001600160a01b031681600001516001600160a01b031614611131576040517fa114810000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000336001600160a01b038616148061114f575061114f85336104aa565b8061116a57503361115f8461074b565b6001600160a01b0316145b9050806111a3576040517f59c896be00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b0384166111e3576040517fea553b3400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6111ef6000848761106c565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff1980821667ffffffffffffffff92831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b429092169190910217835587018084529220805491939091166112c55760005482146112c5578054602086015167ffffffffffffffff16600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505061102c565b604080516060810182526000808252602082018190529181019190915281806001111580156112fd575060005481105b156113dd57600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b810467ffffffffffffffff1692820192909252600160e01b90910460ff161515918101829052906113db5780516001600160a01b031615611371579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b820467ffffffffffffffff1693830193909352600160e01b900460ff16151592810192909252156113d6579392505050565b611371565b505b6040517fdf2d9b4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600880546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a02906114a3903390899088908890600401611b0c565b602060405180830381600087803b1580156114bd57600080fd5b505af19250505080156114ed575060408051601f3d908101601f191682019092526114ea91810190611a0a565b60015b611548573d80801561151b576040519150601f19603f3d011682016040523d82523d6000602084013e611520565b606091505b508051611540576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b6060600b80546106c890611bfb565b6060816115b557505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b81156115df57806115c981611c36565b91506115d89050600a83611ba4565b91506115b9565b60008167ffffffffffffffff8111156115fa576115fa611ca7565b6040519080825280601f01601f191660200182016040528015611624576020820181803683370190505b5090505b841561155e57611639600183611bb8565b9150611646600a86611c51565b611651906030611b8c565b60f81b81838151811061166657611666611c91565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506116a0600a86611ba4565b9450611628565b8280546116b390611bfb565b90600052602060002090601f0160209004810192826116d5576000855561171b565b82601f106116ee57805160ff191683800117855561171b565b8280016001018555821561171b579182015b8281111561171b578251825591602001919060010190611700565b5061172792915061172b565b5090565b5b80821115611727576000815560010161172c565b600067ffffffffffffffff83111561175a5761175a611ca7565b61176d601f8401601f1916602001611b5b565b905082815283838301111561178157600080fd5b828260208301376000602084830101529392505050565b80356001600160a01b03811681146117af57600080fd5b919050565b803580151581146117af57600080fd5b6000602082840312156117d657600080fd5b610d6882611798565b600080604083850312156117f257600080fd5b6117fb83611798565b915061180960208401611798565b90509250929050565b60008060006060848603121561182757600080fd5b61183084611798565b925061183e60208501611798565b9150604084013590509250925092565b6000806000806080858703121561186457600080fd5b61186d85611798565b935061187b60208601611798565b925060408501359150606085013567ffffffffffffffff81111561189e57600080fd5b8501601f810187136118af57600080fd5b6118be87823560208401611740565b91505092959194509250565b600080604083850312156118dd57600080fd5b6118e683611798565b9150611809602084016117b4565b6000806040838503121561190757600080fd5b61191083611798565b946020939093013593505050565b6000602080838503121561193157600080fd5b823567ffffffffffffffff8082111561194957600080fd5b818501915085601f83011261195d57600080fd5b81358181111561196f5761196f611ca7565b8060051b9150611980848301611b5b565b8181528481019084860184860187018a101561199b57600080fd5b600095505b838610156119c5576119b181611798565b8352600195909501949186019186016119a0565b5098975050505050505050565b6000602082840312156119e457600080fd5b610d68826117b4565b6000602082840312156119ff57600080fd5b8135610d6881611cbd565b600060208284031215611a1c57600080fd5b8151610d6881611cbd565b600060208284031215611a3957600080fd5b813567ffffffffffffffff811115611a5057600080fd5b8201601f81018413611a6157600080fd5b61155e84823560208401611740565b600060208284031215611a8257600080fd5b5035919050565b60008151808452611aa1816020860160208601611bcf565b601f01601f19169290920160200192915050565b60008351611ac7818460208801611bcf565b835190830190611adb818360208801611bcf565b7f2e6a736f6e0000000000000000000000000000000000000000000000000000009101908152600501949350505050565b60006001600160a01b03808716835280861660208401525083604083015260806060830152611b3e6080830184611a89565b9695505050505050565b602081526000610d686020830184611a89565b604051601f8201601f1916810167ffffffffffffffff81118282101715611b8457611b84611ca7565b604052919050565b60008219821115611b9f57611b9f611c65565b500190565b600082611bb357611bb3611c7b565b500490565b600082821015611bca57611bca611c65565b500390565b60005b83811015611bea578181015183820152602001611bd2565b83811115610d0b5750506000910152565b600181811c90821680611c0f57607f821691505b60208210811415611c3057634e487b7160e01b600052602260045260246000fd5b50919050565b6000600019821415611c4a57611c4a611c65565b5060010190565b600082611c6057611c60611c7b565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160e01b031981168114610a2a57600080fdfea26469706673582212204418a16dd1f8d99082670efb220a99d197c4af3ae2fcff070bd97b08fe8a4c9564736f6c63430008070033ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef

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

55082:2211:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56815:188;;;;;;;;;;-1:-1:-1;56815:188:0;;;;;:::i;:::-;;:::i;:::-;;37421:305;;;;;;;;;;-1:-1:-1;37421:305:0;;;;;:::i;:::-;;:::i;:::-;;;7092:14:1;;7085:22;7067:41;;7055:2;7040:18;37421:305:0;;;;;;;;57011:87;;;;;;;;;;-1:-1:-1;57011:87:0;;;;;:::i;:::-;;:::i;40473:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;41976:204::-;;;;;;;;;;-1:-1:-1;41976:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;6344:55:1;;;6326:74;;6314:2;6299:18;41976:204:0;6180:226:1;41539:371:0;;;;;;;;;;-1:-1:-1;41539:371:0;;;;;:::i;:::-;;:::i;55199:20::-;;;;;;;;;;;;;;;;;;;9278:25:1;;;9266:2;9251:18;55199:20:0;9132:177:1;36670:303:0;;;;;;;;;;-1:-1:-1;36527:1:0;36924:12;36714:7;36908:13;:28;-1:-1:-1;;36908:46:0;36670:303;;42841:170;;;;;;;;;;-1:-1:-1;42841:170:0;;;;;:::i;:::-;;:::i;55494:352::-;;;;;;:::i;:::-;;:::i;57108:174::-;;;:::i;43082:185::-;;;;;;;;;;-1:-1:-1;43082:185:0;;;;;:::i;:::-;;:::i;56615:192::-;;;;;;;;;;-1:-1:-1;56615:192:0;;;;;:::i;:::-;;:::i;56042:108::-;;;;;;;;;;-1:-1:-1;56042:108:0;;;;;:::i;:::-;;:::i;56491:110::-;;;;;;;;;;-1:-1:-1;56491:110:0;;;;;:::i;:::-;;:::i;40281:125::-;;;;;;;;;;-1:-1:-1;40281:125:0;;;;;:::i;:::-;;:::i;37790:145::-;;;;;;;;;;-1:-1:-1;37790:145:0;;;;;:::i;:::-;-1:-1:-1;;;;;37899:19:0;37854:7;37899:19;;;:12;:19;;;;;:27;;;;37790:145;2488:103;;;;;;;;;;;;;:::i;1837:87::-;;;;;;;;;;-1:-1:-1;1910:6:0;;-1:-1:-1;;;;;1910:6:0;1837:87;;40642:104;;;;;;;;;;;;;:::i;42252:287::-;;;;;;;;;;-1:-1:-1;42252:287:0;;;;;:::i;:::-;;:::i;43338:369::-;;;;;;;;;;-1:-1:-1;43338:369:0;;;;;:::i;:::-;;:::i;56158:296::-;;;;;;;;;;-1:-1:-1;56158:296:0;;;;;:::i;:::-;;:::i;42610:164::-;;;;;;;;;;-1:-1:-1;42610:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;42731:25:0;;;42707:4;42731:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;42610:164;2746:201;;;;;;;;;;-1:-1:-1;2746:201:0;;;;;:::i;:::-;;:::i;56815:188::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;;;;;;;;;56897:9:::1;56892:104;56912:5;:12;56908:1;:16;56892:104;;;56956:28;56962:5;56968:1;56962:8;;;;;;;;:::i;:::-;;;;;;;56972:1;56956:28;;;;;;;;;;;::::0;56979:4:::1;56956:5;:28::i;:::-;56926:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56892:104;;;;56815:188:::0;:::o;37421:305::-;37523:4;-1:-1:-1;;;;;;37560:40:0;;37575:25;37560:40;;:105;;-1:-1:-1;;;;;;;37617:48:0;;37632:33;37617:48;37560:105;:158;;;-1:-1:-1;33120:25:0;-1:-1:-1;;;;;;33105:40:0;;;37682:36;37540:178;37421:305;-1:-1:-1;;37421:305:0:o;57011:87::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;57075:6:::1;:15:::0;;-1:-1:-1;;57075:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;57011:87::o;40473:100::-;40527:13;40560:5;40553:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40473:100;:::o;41976:204::-;42044:7;42069:16;42077:7;42069;:16::i;:::-;42064:64;;42094:34;;;;;;;;;;;;;;42064:64;-1:-1:-1;42148:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;42148:24:0;;41976:204::o;41539:371::-;41612:13;41628:24;41644:7;41628:15;:24::i;:::-;41612:40;;41673:5;-1:-1:-1;;;;;41667:11:0;:2;-1:-1:-1;;;;;41667:11:0;;41663:48;;;41687:24;;;;;;;;;;;;;;41663:48;689:10;-1:-1:-1;;;;;41728:21:0;;;;;;:63;;-1:-1:-1;41754:37:0;41771:5;689:10;42610:164;:::i;41754:37::-;41753:38;41728:63;41724:138;;;41815:35;;;;;;;;;;;;;;41724:138;41874:28;41883:2;41887:7;41896:5;41874:8;:28::i;:::-;41601:309;41539:371;;:::o;42841:170::-;42975:28;42985:4;42991:2;42995:7;42975:9;:28::i;55494:352::-;55563:7;37299:13;-1:-1:-1;;37299:31:0;55620:9;55606:10;:23;55598:51;;;;-1:-1:-1;;;55598:51:0;;8292:2:1;55598:51:0;;;8274:21:1;8331:2;8311:18;;;8304:30;8370:17;8350:18;;;8343:45;8405:18;;55598:51:0;8090:339:1;55598:51:0;55672:1;55668:3;:5;55660:28;;;;-1:-1:-1;;;55660:28:0;;7545:2:1;55660:28:0;;;7527:21:1;7584:2;7564:18;;;7557:30;7623:13;7603:18;;;7596:41;7654:18;;55660:28:0;7343:335:1;55660:28:0;55718:4;55707:8;55712:3;55707:2;:8;:::i;:::-;:15;55699:37;;;;-1:-1:-1;;;55699:37:0;;8636:2:1;55699:37:0;;;8618:21:1;8675:1;8655:18;;;8648:29;-1:-1:-1;;;8693:18:1;;;8686:39;8742:18;;55699:37:0;8434:332:1;55699:37:0;55801:30;55807:10;55819:3;55801:30;;;;;;;;;;;;55826:4;55801:5;:30::i;57108:174::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;57189:58:::1;::::0;57171:12:::1;::::0;57197:10:::1;::::0;57221:21:::1;::::0;57171:12;57189:58;57171:12;57189:58;57221:21;57197:10;57189:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57170:77;;;57266:7;57258:16;;;::::0;::::1;;57159:123;57108:174::o:0;43082:185::-;43220:39;43237:4;43243:2;43247:7;43220:39;;;;;;;;;;;;:16;:39::i;56615:192::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;56728:5:::1;56723:3;56706:14;37113:7:::0;37299:13;-1:-1:-1;;37299:31:0;;37066:283;56706:14:::1;:20;;;;:::i;:::-;:27;56698:49;;;::::0;-1:-1:-1;;;56698:49:0;;8636:2:1;56698:49:0::1;::::0;::::1;8618:21:1::0;8675:1;8655:18;;;8648:29;-1:-1:-1;;;8693:18:1;;;8686:39;8742:18;;56698:49:0::1;8434:332:1::0;56698:49:0::1;56768:31;56774:9;56785:3;56768:31;;;;;;;;;;;::::0;56794:4:::1;56768:5;:31::i;56042:108::-:0;56096:4;56126:16;56134:7;56126;:16::i;56491:110::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;56570:23;;::::1;::::0;:13:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;40281:125::-:0;40345:7;40372:21;40385:7;40372:12;:21::i;:::-;:26;;40281:125;-1:-1:-1;;40281:125:0:o;2488:103::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;2553:30:::1;2580:1;2553:18;:30::i;:::-;2488:103::o:0;40642:104::-;40698:13;40731:7;40724:14;;;;;:::i;42252:287::-;-1:-1:-1;;;;;42351:24:0;;689:10;42351:24;42347:54;;;42384:17;;;;;;;;;;;;;;42347:54;689:10;42414:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;42414:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;42414:53:0;;;;;;;;;;42483:48;;7067:41:1;;;42414:42:0;;689:10;42483:48;;7040:18:1;42483:48:0;;;;;;;42252:287;;:::o;43338:369::-;43505:28;43515:4;43521:2;43525:7;43505:9;:28::i;:::-;-1:-1:-1;;;;;43548:13:0;;10430:19;:23;;43548:76;;;;;43568:56;43599:4;43605:2;43609:7;43618:5;43568:30;:56::i;:::-;43567:57;43548:76;43544:156;;;43648:40;;-1:-1:-1;;;43648:40:0;;;;;;;;;;;43544:156;43338:369;;;;:::o;56158:296::-;56228:13;56264:28;56295:10;:8;:10::i;:::-;56264:41;;56350:1;56325:14;56319:28;:32;:127;;;;;;;;;;;;;;;;;56387:14;56403:18;:7;:16;:18::i;:::-;56370:61;;;;;;;;;:::i;:::-;;;;;;;;;;;;;56319:127;56312:134;56158:296;-1:-1:-1;;;56158:296:0:o;2746:201::-;1910:6;;-1:-1:-1;;;;;1910:6:0;689:10;2057:23;2049:68;;;;-1:-1:-1;;;2049:68:0;;8973:2:1;2049:68:0;;;8955:21:1;;;8992:18;;;8985:30;9051:34;9031:18;;;9024:62;9103:18;;2049:68:0;8771:356:1;2049:68:0;-1:-1:-1;;;;;2835:22:0;::::1;2827:73;;;::::0;-1:-1:-1;;;2827:73:0;;7885:2:1;2827:73:0::1;::::0;::::1;7867:21:1::0;7924:2;7904:18;;;7897:30;7963:34;7943:18;;;7936:62;8034:8;8014:18;;;8007:36;8060:19;;2827:73:0::1;7683:402:1::0;2827:73:0::1;2911:28;2930:8;2911:18;:28::i;10135:326::-:0;-1:-1:-1;;;;;10430:19:0;;:23;;;10135:326::o;45033:1763::-;45182:20;45205:13;45243;45239:44;;45265:18;;;;;;;;;;;;;;45239:44;-1:-1:-1;;;;;45661:16:0;;;;;;:12;:16;;;;;;;;:44;;45720:49;;;45661:44;;;;;;;;45720:49;;;;-1:-1:-1;;45661:44:0;;;;;;45720:49;;;;;;;;;;;;;;;;45786:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;45836:66:0;;;;-1:-1:-1;;;45886:15:0;45836:66;;;;;;;;;;45786:25;45983:23;;;46027:4;:23;;;;-1:-1:-1;;;;;;46035:13:0;;10430:19;:23;;46035:15;46023:641;;;46071:314;46102:38;;46127:12;;-1:-1:-1;;;;;46102:38:0;;;46119:1;;46102:38;;46119:1;;46102:38;46168:69;46207:1;46211:2;46215:14;;;;;;46231:5;46168:30;:69::i;:::-;46163:174;;46273:40;;-1:-1:-1;;;46273:40:0;;;;;;;;;;;46163:174;46380:3;46364:12;:19;;46071:314;;46466:12;46449:13;;:29;46445:43;;46480:8;;;46445:43;46023:641;;;46529:120;46560:40;;46585:14;;;;;-1:-1:-1;;;;;46560:40:0;;;46577:1;;46560:40;;46577:1;;46560:40;46644:3;46628:12;:19;;46529:120;;46023:641;-1:-1:-1;46678:13:0;:28;46728:60;45161:1635;45033:1763;;;;:::o;43962:174::-;44019:4;44062:7;36527:1;44043:26;;:53;;;;;44083:13;;44073:7;:23;44043:53;:85;;;;-1:-1:-1;;44101:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;44101:27:0;;;;44100:28;;43962:174::o;52065:196::-;52180:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;52180:29:0;-1:-1:-1;;;;;52180:29:0;;;;;;;;;52225:28;;52180:24;;52225:28;;;;;;;52065:196;;;:::o;47050:2088::-;47165:35;47203:21;47216:7;47203:12;:21::i;:::-;47165:59;;47263:4;-1:-1:-1;;;;;47241:26:0;:13;:18;;;-1:-1:-1;;;;;47241:26:0;;47237:67;;47276:28;;;;;;;;;;;;;;47237:67;47317:22;689:10;-1:-1:-1;;;;;47343:20:0;;;;:73;;-1:-1:-1;47380:36:0;47397:4;689:10;42610:164;:::i;47380:36::-;47343:126;;;-1:-1:-1;689:10:0;47433:20;47445:7;47433:11;:20::i;:::-;-1:-1:-1;;;;;47433:36:0;;47343:126;47317:153;;47488:17;47483:66;;47514:35;;;;;;;;;;;;;;47483:66;-1:-1:-1;;;;;47564:16:0;;47560:52;;47589:23;;;;;;;;;;;;;;47560:52;47733:35;47750:1;47754:7;47763:4;47733:8;:35::i;:::-;-1:-1:-1;;;;;48064:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;48064:31:0;;;;;;;-1:-1:-1;;48064:31:0;;;;;;;48110:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;48110:29:0;;;;;;;;;;;48190:20;;;:11;:20;;;;;;48225:18;;-1:-1:-1;;;;;;48258:49:0;;;;-1:-1:-1;;;48291:15:0;48258:49;;;;;;;;;;48581:11;;48641:24;;;;;48684:13;;48190:20;;48641:24;;48684:13;48680:384;;48894:13;;48879:11;:28;48875:174;;48932:20;;49001:28;;;;48975:54;;-1:-1:-1;;;48975:54:0;-1:-1:-1;;;;;;48975:54:0;;;-1:-1:-1;;;;;48932:20:0;;48975:54;;;;48875:174;48039:1036;;;49088:42;43338:369;39110:1109;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;39221:7:0;;36527:1;39270:23;;:47;;;;;39304:13;;39297:4;:20;39270:47;39266:886;;;39338:31;39372:17;;;:11;:17;;;;;;;;;39338:51;;;;;;;;;-1:-1:-1;;;;;39338:51:0;;;;-1:-1:-1;;;39338:51:0;;;;;;;;;;;-1:-1:-1;;;39338:51:0;;;;;;;;;;;;;;39408:729;;39458:14;;-1:-1:-1;;;;;39458:28:0;;39454:101;;39522:9;39110:1109;-1:-1:-1;;;39110:1109:0:o;39454:101::-;-1:-1:-1;;;39897:6:0;39942:17;;;;:11;:17;;;;;;;;;39930:29;;;;;;;;;-1:-1:-1;;;;;39930:29:0;;;;;-1:-1:-1;;;39930:29:0;;;;;;;;;;;-1:-1:-1;;;39930:29:0;;;;;;;;;;;;;39990:28;39986:109;;40058:9;39110:1109;-1:-1:-1;;;39110:1109:0:o;39986:109::-;39857:261;;;39319:833;39266:886;40180:31;;;;;;;;;;;;;;3107:191;3200:6;;;-1:-1:-1;;;;;3217:17:0;;;-1:-1:-1;;3217:17:0;;;;;;;3250:40;;3200:6;;;3217:17;3200:6;;3250:40;;3181:16;;3250:40;3170:128;3107:191;:::o;52753:667::-;52937:72;;-1:-1:-1;;;52937:72:0;;52916:4;;-1:-1:-1;;;;;52937:36:0;;;;;:72;;689:10;;52988:4;;52994:7;;53003:5;;52937:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52937:72:0;;;;;;;;-1:-1:-1;;52937:72:0;;;;;;;;;;;;:::i;:::-;;;52933:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53171:13:0;;53167:235;;53217:40;;-1:-1:-1;;;53217:40:0;;;;;;;;;;;53167:235;53360:6;53354:13;53345:6;53341:2;53337:15;53330:38;52933:480;-1:-1:-1;;;;;;53056:55:0;-1:-1:-1;;;53056:55:0;;-1:-1:-1;52933:480:0;52753:667;;;;;;:::o;55914:120::-;55974:13;56013;56006:20;;;;;:::i;30366:723::-;30422:13;30643:10;30639:53;;-1:-1:-1;;30670:10:0;;;;;;;;;;;;;;;;;;30366:723::o;30639:53::-;30717:5;30702:12;30758:78;30765:9;;30758:78;;30791:8;;;;:::i;:::-;;-1:-1:-1;30814:10:0;;-1:-1:-1;30822:2:0;30814:10;;:::i;:::-;;;30758:78;;;30846:19;30878:6;30868:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30868:17:0;;30846:39;;30896:154;30903:10;;30896:154;;30930:11;30940:1;30930:11;;:::i;:::-;;-1:-1:-1;30999:10:0;31007:2;30999:5;:10;:::i;:::-;30986:24;;:2;:24;:::i;:::-;30973:39;;30956:6;30963;30956:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;31027:11:0;31036:2;31027:11;;:::i;:::-;;;30896:154;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;112:18;104:6;101:30;98:56;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:45;;;309:1;306;299:12;268:45;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;14:406;;;;;:::o;425:196::-;493:20;;-1:-1:-1;;;;;542:54:1;;532:65;;522:93;;611:1;608;601:12;522:93;425:196;;;:::o;626:160::-;691:20;;747:13;;740:21;730:32;;720:60;;776:1;773;766:12;791:186;850:6;903:2;891:9;882:7;878:23;874:32;871:52;;;919:1;916;909:12;871:52;942:29;961:9;942:29;:::i;982:260::-;1050:6;1058;1111:2;1099:9;1090:7;1086:23;1082:32;1079:52;;;1127:1;1124;1117:12;1079:52;1150:29;1169:9;1150:29;:::i;:::-;1140:39;;1198:38;1232:2;1221:9;1217:18;1198:38;:::i;:::-;1188:48;;982:260;;;;;:::o;1247:328::-;1324:6;1332;1340;1393:2;1381:9;1372:7;1368:23;1364:32;1361:52;;;1409:1;1406;1399:12;1361:52;1432:29;1451:9;1432:29;:::i;:::-;1422:39;;1480:38;1514:2;1503:9;1499:18;1480:38;:::i;:::-;1470:48;;1565:2;1554:9;1550:18;1537:32;1527:42;;1247:328;;;;;:::o;1580:666::-;1675:6;1683;1691;1699;1752:3;1740:9;1731:7;1727:23;1723:33;1720:53;;;1769:1;1766;1759:12;1720:53;1792:29;1811:9;1792:29;:::i;:::-;1782:39;;1840:38;1874:2;1863:9;1859:18;1840:38;:::i;:::-;1830:48;;1925:2;1914:9;1910:18;1897:32;1887:42;;1980:2;1969:9;1965:18;1952:32;2007:18;1999:6;1996:30;1993:50;;;2039:1;2036;2029:12;1993:50;2062:22;;2115:4;2107:13;;2103:27;-1:-1:-1;2093:55:1;;2144:1;2141;2134:12;2093:55;2167:73;2232:7;2227:2;2214:16;2209:2;2205;2201:11;2167:73;:::i;:::-;2157:83;;;1580:666;;;;;;;:::o;2251:254::-;2316:6;2324;2377:2;2365:9;2356:7;2352:23;2348:32;2345:52;;;2393:1;2390;2383:12;2345:52;2416:29;2435:9;2416:29;:::i;:::-;2406:39;;2464:35;2495:2;2484:9;2480:18;2464:35;:::i;2510:254::-;2578:6;2586;2639:2;2627:9;2618:7;2614:23;2610:32;2607:52;;;2655:1;2652;2645:12;2607:52;2678:29;2697:9;2678:29;:::i;:::-;2668:39;2754:2;2739:18;;;;2726:32;;-1:-1:-1;;;2510:254:1:o;2769:963::-;2853:6;2884:2;2927;2915:9;2906:7;2902:23;2898:32;2895:52;;;2943:1;2940;2933:12;2895:52;2983:9;2970:23;3012:18;3053:2;3045:6;3042:14;3039:34;;;3069:1;3066;3059:12;3039:34;3107:6;3096:9;3092:22;3082:32;;3152:7;3145:4;3141:2;3137:13;3133:27;3123:55;;3174:1;3171;3164:12;3123:55;3210:2;3197:16;3232:2;3228;3225:10;3222:36;;;3238:18;;:::i;:::-;3284:2;3281:1;3277:10;3267:20;;3307:28;3331:2;3327;3323:11;3307:28;:::i;:::-;3369:15;;;3400:12;;;;3432:11;;;3462;;;3458:20;;3455:33;-1:-1:-1;3452:53:1;;;3501:1;3498;3491:12;3452:53;3523:1;3514:10;;3533:169;3547:2;3544:1;3541:9;3533:169;;;3604:23;3623:3;3604:23;:::i;:::-;3592:36;;3565:1;3558:9;;;;;3648:12;;;;3680;;3533:169;;;-1:-1:-1;3721:5:1;2769:963;-1:-1:-1;;;;;;;;2769:963:1:o;3737:180::-;3793:6;3846:2;3834:9;3825:7;3821:23;3817:32;3814:52;;;3862:1;3859;3852:12;3814:52;3885:26;3901:9;3885:26;:::i;3922:245::-;3980:6;4033:2;4021:9;4012:7;4008:23;4004:32;4001:52;;;4049:1;4046;4039:12;4001:52;4088:9;4075:23;4107:30;4131:5;4107:30;:::i;4172:249::-;4241:6;4294:2;4282:9;4273:7;4269:23;4265:32;4262:52;;;4310:1;4307;4300:12;4262:52;4342:9;4336:16;4361:30;4385:5;4361:30;:::i;4426:450::-;4495:6;4548:2;4536:9;4527:7;4523:23;4519:32;4516:52;;;4564:1;4561;4554:12;4516:52;4604:9;4591:23;4637:18;4629:6;4626:30;4623:50;;;4669:1;4666;4659:12;4623:50;4692:22;;4745:4;4737:13;;4733:27;-1:-1:-1;4723:55:1;;4774:1;4771;4764:12;4723:55;4797:73;4862:7;4857:2;4844:16;4839:2;4835;4831:11;4797:73;:::i;4881:180::-;4940:6;4993:2;4981:9;4972:7;4968:23;4964:32;4961:52;;;5009:1;5006;4999:12;4961:52;-1:-1:-1;5032:23:1;;4881:180;-1:-1:-1;4881:180:1:o;5066:257::-;5107:3;5145:5;5139:12;5172:6;5167:3;5160:19;5188:63;5244:6;5237:4;5232:3;5228:14;5221:4;5214:5;5210:16;5188:63;:::i;:::-;5305:2;5284:15;-1:-1:-1;;5280:29:1;5271:39;;;;5312:4;5267:50;;5066:257;-1:-1:-1;;5066:257:1:o;5328:637::-;5608:3;5646:6;5640:13;5662:53;5708:6;5703:3;5696:4;5688:6;5684:17;5662:53;:::i;:::-;5778:13;;5737:16;;;;5800:57;5778:13;5737:16;5834:4;5822:17;;5800:57;:::i;:::-;5922:7;5879:20;;5908:22;;;5957:1;5946:13;;5328:637;-1:-1:-1;;;;5328:637:1:o;6411:511::-;6605:4;-1:-1:-1;;;;;6715:2:1;6707:6;6703:15;6692:9;6685:34;6767:2;6759:6;6755:15;6750:2;6739:9;6735:18;6728:43;;6807:6;6802:2;6791:9;6787:18;6780:34;6850:3;6845:2;6834:9;6830:18;6823:31;6871:45;6911:3;6900:9;6896:19;6888:6;6871:45;:::i;:::-;6863:53;6411:511;-1:-1:-1;;;;;;6411:511:1:o;7119:219::-;7268:2;7257:9;7250:21;7231:4;7288:44;7328:2;7317:9;7313:18;7305:6;7288:44;:::i;9314:275::-;9385:2;9379:9;9450:2;9431:13;;-1:-1:-1;;9427:27:1;9415:40;;9485:18;9470:34;;9506:22;;;9467:62;9464:88;;;9532:18;;:::i;:::-;9568:2;9561:22;9314:275;;-1:-1:-1;9314:275:1:o;9594:128::-;9634:3;9665:1;9661:6;9658:1;9655:13;9652:39;;;9671:18;;:::i;:::-;-1:-1:-1;9707:9:1;;9594:128::o;9727:120::-;9767:1;9793;9783:35;;9798:18;;:::i;:::-;-1:-1:-1;9832:9:1;;9727:120::o;9852:125::-;9892:4;9920:1;9917;9914:8;9911:34;;;9925:18;;:::i;:::-;-1:-1:-1;9962:9:1;;9852:125::o;9982:258::-;10054:1;10064:113;10078:6;10075:1;10072:13;10064:113;;;10154:11;;;10148:18;10135:11;;;10128:39;10100:2;10093:10;10064:113;;;10195:6;10192:1;10189:13;10186:48;;;-1:-1:-1;;10230:1:1;10212:16;;10205:27;9982:258::o;10245:437::-;10324:1;10320:12;;;;10367;;;10388:61;;10442:4;10434:6;10430:17;10420:27;;10388:61;10495:2;10487:6;10484:14;10464:18;10461:38;10458:218;;;-1:-1:-1;;;10529:1:1;10522:88;10633:4;10630:1;10623:15;10661:4;10658:1;10651:15;10458:218;;10245:437;;;:::o;10687:135::-;10726:3;-1:-1:-1;;10747:17:1;;10744:43;;;10767:18;;:::i;:::-;-1:-1:-1;10814:1:1;10803:13;;10687:135::o;10827:112::-;10859:1;10885;10875:35;;10890:18;;:::i;:::-;-1:-1:-1;10924:9:1;;10827:112::o;10944:184::-;-1:-1:-1;;;10993:1:1;10986:88;11093:4;11090:1;11083:15;11117:4;11114:1;11107:15;11133:184;-1:-1:-1;;;11182:1:1;11175:88;11282:4;11279:1;11272:15;11306:4;11303:1;11296:15;11322:184;-1:-1:-1;;;11371:1:1;11364:88;11471:4;11468:1;11461:15;11495:4;11492:1;11485:15;11511:184;-1:-1:-1;;;11560:1:1;11553:88;11660:4;11657:1;11650:15;11684:4;11681:1;11674:15;11700:177;-1:-1:-1;;;;;;11778:5:1;11774:78;11767:5;11764:89;11754:117;;11867:1;11864;11857:12

ipfs://4418a16dd1f8d99082670efb220a99d197c4af3ae2fcff070bd97b08fe8a4c95