Token

Steady Stack Legends (SSL)

ERC-721

Overview

Max Total Supply

9,999 SSL

Holders

1,215

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xea14fb44f85650d06d505966b1d02ca1f599b823

Filtered by Token Holder

0x4297DB69047F834514034EaCEec3fa0F807e32a7

regiep.eth

Balance

1 SSL

0x4297db69047f834514034eaceec3fa0f807e32a7

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SSLegends

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-05-02
*/

// Created by Byt, Inc. https://byt.io
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

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

/**
 * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, 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);
}

/**
 * @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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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);
            }
        }
    }
}

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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 *
 * @dev original library functions truncated to only needed functions reducing
 * deployed bytecode.
 */
library SafeMath {

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }
}

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


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


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


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


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


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

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


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


/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
 *
 * Does not support burning tokens to address(0).
 */
contract ERC721A is
  Context,
  ERC165,
  IERC721,
  IERC721Metadata,
  IERC721Enumerable
{
  using Address for address;
  using Strings for uint256;

  struct TokenOwnership {
    address addr;
    uint64 startTimestamp;
  }

  struct AddressData {
    uint128 balance;
    uint128 numberMinted;
  }

  uint256 private currentIndex = 0;

  uint256 internal immutable collectionSize;
  uint256 internal immutable maxBatchSize;

  // 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) private _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;

  /**
   * @dev
   * `maxBatchSize` refers to how much a minter can mint at a time.
   * `collectionSize_` refers to how many tokens are in the collection.
   */
  constructor(
    string memory name_,
    string memory symbol_,
    uint256 maxBatchSize_,
    uint256 collectionSize_
  ) {
    require(
      collectionSize_ > 0,
      "ERC721A: collection must have a nonzero supply"
    );
    require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
    _name = name_;
    _symbol = symbol_;
    maxBatchSize = maxBatchSize_;
    collectionSize = collectionSize_;
  }

  /**
   * @dev See {IERC721Enumerable-totalSupply}.
   */
  function totalSupply() public view override returns (uint256) {
    return currentIndex;
  }

  /**
   * @dev See {IERC721Enumerable-tokenByIndex}.
   */
  function tokenByIndex(uint256 index) public view override returns (uint256) {
    require(index < totalSupply(), "ERC721A: global index out of bounds");
    return index;
  }

  /**
   * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
   * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
   * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
   */
  function tokenOfOwnerByIndex(address owner, uint256 index)
    public
    view
    override
    returns (uint256)
  {
    require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
    uint256 numMintedSoFar = totalSupply();
    uint256 tokenIdsIdx = 0;
    address currOwnershipAddr = address(0);
    for (uint256 i = 0; i < numMintedSoFar; i++) {
      TokenOwnership memory ownership = _ownerships[i];
      if (ownership.addr != address(0)) {
        currOwnershipAddr = ownership.addr;
      }
      if (currOwnershipAddr == owner) {
        if (tokenIdsIdx == index) {
          return i;
        }
        tokenIdsIdx++;
      }
    }
    revert("ERC721A: unable to get token of owner by index");
  }

  /**
   * @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 ||
      interfaceId == type(IERC721Enumerable).interfaceId ||
      super.supportsInterface(interfaceId);
  }

  /**
   * @dev See {IERC721-balanceOf}.
   */
  function balanceOf(address owner) public view override returns (uint256) {
    require(owner != address(0), "ERC721A: balance query for the zero address");
    return uint256(_addressData[owner].balance);
  }

  function _numberMinted(address owner) internal view returns (uint256) {
    require(
      owner != address(0),
      "ERC721A: number minted query for the zero address"
    );
    return uint256(_addressData[owner].numberMinted);
  }

  function ownershipOf(uint256 tokenId)
    internal
    view
    returns (TokenOwnership memory)
  {
    require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

    uint256 lowestTokenToCheck;
    if (tokenId >= maxBatchSize) {
      lowestTokenToCheck = tokenId - maxBatchSize + 1;
    }

    for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
      TokenOwnership memory ownership = _ownerships[curr];
      if (ownership.addr != address(0)) {
        return ownership;
      }
    }

    revert("ERC721A: unable to determine the owner of token");
  }

  /**
   * @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)
  {
    require(
      _exists(tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );

    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 virtual override {
    address owner = ERC721A.ownerOf(tokenId);
    require(to != owner, "ERC721A: approval to current owner");

    require(
      _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
      "ERC721A: approve caller is not owner nor approved for all"
    );

    _approve(to, tokenId, owner);
  }

  /**
   * @dev See {IERC721-getApproved}.
   */
  function getApproved(uint256 tokenId) public view override returns (address) {
    require(_exists(tokenId), "ERC721A: approved query for nonexistent token");

    return _tokenApprovals[tokenId];
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   */
  function setApprovalForAll(address operator, bool approved) public virtual override {
    require(operator != _msgSender(), "ERC721A: approve to caller");

    _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);
    require(
      _checkOnERC721Received(from, to, tokenId, _data),
      "ERC721A: transfer to non ERC721Receiver implementer"
    );
  }

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

  function _safeMint(address to, uint256 quantity) internal {
    _safeMint(to, quantity, "");
  }

  /**
   * @dev Mints `quantity` tokens and transfers them to `to`.
   *
   * Requirements:
   *
   * - there must be `quantity` tokens remaining unminted in the total collection.
   * - `to` cannot be the zero address.
   * - `quantity` cannot be larger than the max batch size.
   *
   * Emits a {Transfer} event.
   */
  function _safeMint(
    address to,
    uint256 quantity,
    bytes memory _data
  ) internal {
    uint256 startTokenId = currentIndex;
    require(to != address(0), "ERC721A: mint to the zero address");
    // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
    require(!_exists(startTokenId), "ERC721A: token already minted");
    require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");

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

    AddressData memory addressData = _addressData[to];
    _addressData[to] = AddressData(
      addressData.balance + uint128(quantity),
      addressData.numberMinted + uint128(quantity)
    );
    _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));

    uint256 updatedIndex = startTokenId;

    for (uint256 i = 0; i < quantity; i++) {
      emit Transfer(address(0), to, updatedIndex);
      require(
        _checkOnERC721Received(address(0), to, updatedIndex, _data),
        "ERC721A: transfer to non ERC721Receiver implementer"
      );
      updatedIndex++;
    }

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

    bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
      getApproved(tokenId) == _msgSender() ||
      isApprovedForAll(prevOwnership.addr, _msgSender()));

    require(
      isApprovedOrOwner,
      "ERC721A: transfer caller is not owner nor approved"
    );

    require(
      prevOwnership.addr == from,
      "ERC721A: transfer from incorrect owner"
    );
    require(to != address(0), "ERC721A: transfer to the zero address");

    _beforeTokenTransfers(from, to, tokenId, 1);

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

    _addressData[from].balance -= 1;
    _addressData[to].balance += 1;
    _ownerships[tokenId] = TokenOwnership(to, 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;
    if (_ownerships[nextTokenId].addr == address(0)) {
      if (_exists(nextTokenId)) {
        _ownerships[nextTokenId] = TokenOwnership(
          prevOwnership.addr,
          prevOwnership.startTimestamp
        );
      }
    }

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

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

  uint256 public nextOwnerToExplicitlySet = 0;

  /**
   * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
   */
  function _setOwnersExplicit(uint256 quantity) internal {
    uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
    require(quantity > 0, "quantity must be nonzero");
    uint256 endIndex = oldNextOwnerToSet + quantity - 1;
    if (endIndex > collectionSize - 1) {
      endIndex = collectionSize - 1;
    }
    // We know if the last one in the group exists, all in the group exist, due to serial ordering.
    require(_exists(endIndex), "not enough minted yet for this cleanup");
    for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
      if (_ownerships[i].addr == address(0)) {
        TokenOwnership memory ownership = ownershipOf(i);
        _ownerships[i] = TokenOwnership(
          ownership.addr,
          ownership.startTimestamp
        );
      }
    }
    nextOwnerToExplicitlySet = endIndex + 1;
  }

  /**
   * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
   * The call is not executed if the target address is not a 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 _checkOnERC721Received(
    address from,
    address to,
    uint256 tokenId,
    bytes memory _data
  ) private returns (bool) {
    if (to.isContract()) {
      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("ERC721A: transfer to non ERC721Receiver implementer");
        } else {
          assembly {
            revert(add(32, reason), mload(reason))
          }
        }
      }
    } else {
      return true;
    }
  }

  /**
   * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
   *
   * 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`.
   */
  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.
   *
   * 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` and `to` are never both zero.
   */
  function _afterTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
  ) internal virtual {}
}

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address registrantToSubscribe) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address addr) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public iOperatorFilterRegistry;

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(iOperatorFilterRegistry).code.length > 0) {
            if (subscribe) {
                iOperatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    iOperatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    iOperatorFilterRegistry.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(iOperatorFilterRegistry).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (!iOperatorFilterRegistry.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)
/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
  using Strings for uint256;
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

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

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

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

contract SSLegends is Ownable, ERC721A, ReentrancyGuard, OperatorFilterer {
  using ECDSA for bytes32;
  using SafeMath for uint256;

  event OperatorFilterRegistryAddressUpdated(address newRegistry);

  address public signer;

  uint256 public immutable maxPerAddressDuringMint;
  uint256 public immutable amountForWhitelistAndPublic;

  uint256 public maxWhitelistMints;
  uint256 public maxPublicMintsPerTxn;

  address payoutWallet1;
  address payoutWallet2;
  address rerollPayoutWallet;

  uint256 secondaryPartyFee;

  uint256 public saleStartTime;
  uint256 public whitelistStartTime;
  uint256 public goldlistStartTime;


  uint256 public publicSaleCost;
  uint256 public whitelistSaleCost;

  bytes32[] _whitelistRootHash;

  //Using a mapping to track whitelist mints for wallets
  mapping(address => uint256) public whitelistMints;
  //Using a mapping to track goldlist mints for wallets
  mapping(address => uint256) public goldlistMints;
  //Using a mapping for nonces to validate signatures
  mapping(address => uint256) public addressNonce;
  //Mapping to tell if a token was whitelist minted
  mapping(uint256 => bool) public isTokenWhitelistMinted;

  event TokenReRoll(
    uint256 indexed allotmentId
  );

  event GoldlistMint(
    uint256[] allotmentIds,
    uint256[] tokenIds
  );

  event WhitelistMint(
    uint256 startingTokenId,
    uint256 quantity
  );

  constructor(
    uint256 maxBatchSize_,
    uint256 collectionSize_,
    uint256 amountForWhitelistAndPublic_,
    address ioperatorFilterRegistry_,
    address subscriptionOrRegistrantToCopy
  ) ERC721A("Steady Stack Legends", "SSL", maxBatchSize_, collectionSize_) OperatorFilterer(subscriptionOrRegistrantToCopy, true) {
    maxPerAddressDuringMint = maxBatchSize_;
    amountForWhitelistAndPublic = amountForWhitelistAndPublic_;
    require(
      amountForWhitelistAndPublic_ <= collectionSize_,
      "larger collection size needed"
    );
    publicSaleCost = 0.6 ether;
    whitelistSaleCost = 0.5 ether;
    maxWhitelistMints = 1;
    maxPublicMintsPerTxn = 1;
    secondaryPartyFee = 20;
    payoutWallet1 = address(0xA571c6075Ea2DF601909E914E36198528CE610E3);
    payoutWallet2 = address(0xaF62166f50b13Db316C6111Da92E4c694a75EBbd);
    rerollPayoutWallet = address(0x735553423d83572ccd809c587a72d147852DcEB3);

    iOperatorFilterRegistry = IOperatorFilterRegistry(ioperatorFilterRegistry_);
    if (subscriptionOrRegistrantToCopy != address(0)) {
      iOperatorFilterRegistry.registerAndCopyEntries(
        address(this),
        subscriptionOrRegistrantToCopy
      );
    } else {
      iOperatorFilterRegistry.register(address(this));
    }
  }

  function setIOperatorFilterRegistry(address _iOperatorFilterRegistry) external onlyOwner {
    iOperatorFilterRegistry = IOperatorFilterRegistry(_iOperatorFilterRegistry);
    emit OperatorFilterRegistryAddressUpdated(_iOperatorFilterRegistry);
  }

  function updatePayoutWallet(address _newPayoutWallet, bool firstWallet) external onlyOwner{
    if(firstWallet){
      payoutWallet1 = _newPayoutWallet;
    }
    else{
      payoutWallet2 = _newPayoutWallet;
    }
  }

  function updateRerollPayoutWallet(address _newRerollPayoutWallet) external onlyOwner{
      rerollPayoutWallet = _newRerollPayoutWallet;
  }

  function addToWhitelistRootHash(bytes32 _hash) public onlyOwner{
        _whitelistRootHash.push(_hash);
  }

  function clearWhitelist() external onlyOwner{
    delete _whitelistRootHash;
  }

  function setWhitelistStartTime(uint256 _time) external onlyOwner {
    whitelistStartTime = _time;
    goldlistStartTime = _time;
  }

  function setGoldlistStartTimeExplicit(uint256 _time) external onlyOwner{
    goldlistStartTime = _time;
  }

  function setSaleStartTime(uint256 _time) external onlyOwner {
    saleStartTime = _time;
  }

  function setWhitelistSaleCost(uint256 _cost) public onlyOwner{
    whitelistSaleCost = _cost;
  }

  function setPublicSaleCost(uint256 _cost) external onlyOwner {
    publicSaleCost = _cost;
  }

  function getMintedTokenIds(uint256 startingIndex, uint256 quantity) internal pure returns (uint256[] memory) {
      // Create an array with the specified length
      uint256[] memory tokenIds = new uint256[](quantity);

      // Iterate through the loop to populate the array
      for (uint256 i = 0; i < quantity; i++) {
          tokenIds[i] = startingIndex + i;
      }

      return tokenIds;
  }

  function reRoll(uint256 allotmentId, uint256 reRollCost, uint256 nonce, bytes calldata signature) external payable {
    require(verifyRerollSignature(msg.sender, allotmentId, reRollCost, nonce, signature), "invalid re-roll data");
    require(addressNonce[msg.sender] == nonce, "incorrect nonce");
    refundIfOver(reRollCost);
    addressNonce[msg.sender] = addressNonce[msg.sender] + 1;
    payable(rerollPayoutWallet).transfer(reRollCost);
    emit TokenReRoll(allotmentId);
  }

  function publicMint(uint256 quantity) external payable {
    require(saleStartTime != 0 && block.timestamp >= saleStartTime, "sale has not started yet");
    require(totalSupply() + quantity <= amountForWhitelistAndPublic, "not enough remaining to support desired mint amount");
    require(quantity < maxPublicMintsPerTxn, "Can't mint that many in a single transaction");

    uint256 totalCost = publicSaleCost * quantity;
    _safeMint(_msgSender(), quantity);
    refundIfOver(totalCost);
  }

  function goldlistMint(uint256[] calldata allotmentIds, uint256 nonce, bytes calldata signature) external {
    uint256 quantity = allotmentIds.length;

    require(verifyMintSignature(msg.sender, allotmentIds, nonce, signature), "Invalid signature");
    require(addressNonce[msg.sender] == nonce, "incorrect nonce");
    require(goldlistStartTime != 0 && block.timestamp >= goldlistStartTime, "The sale has not started yet");

    uint256[] memory tokenIds = getMintedTokenIds(totalSupply(), quantity);

    _safeMint(_msgSender(), quantity);

    goldlistMints[_msgSender()] += quantity;
    addressNonce[msg.sender] = addressNonce[msg.sender] + 1;
    emit GoldlistMint(allotmentIds, tokenIds);
  }

  function whitelistMint(uint256 quantity, uint256 spotInWhitelist, uint256 maxMints, bytes32[] memory proof) external payable {
    require(whitelistValidated(_msgSender(), spotInWhitelist, maxMints, proof), "You're not on the whitelist");
    require(whitelistStartTime != 0 && block.timestamp >= whitelistStartTime, "The sale has not started yet");
    require(totalSupply() + quantity <= amountForWhitelistAndPublic, "not enough remaining reserved for whitelist to support desired mint amount");
    require(whitelistMints[_msgSender()] + quantity <= maxWhitelistMints, "This address already whitelist minted");

    uint256 premintIndex = totalSupply();
    isTokenWhitelistMinted[premintIndex] = true;

    whitelistMints[_msgSender()] += quantity;

    _safeMint(_msgSender(), quantity);
    refundIfOver(whitelistSaleCost * quantity);
    emit WhitelistMint(premintIndex, quantity);
  }

  function refundIfOver(uint256 price) private {
    require(msg.value >= price, "Need to send more ETH.");
    if (msg.value > price) {
      payable(_msgSender()).transfer(msg.value - price);
    }
  }

  function getCurrentCost() public view returns (uint256) {
    if(saleStartTime != 0 && block.timestamp >= saleStartTime) {
      return publicSaleCost;
    }
    else {
      return whitelistSaleCost;
    }
  }

  function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
      super.setApprovalForAll(operator, approved);
  }

  function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
      super.approve(operator, tokenId);
  }

  function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
      super.transferFrom(from, to, tokenId);
  }

  function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
      super.safeTransferFrom(from, to, tokenId);
  }

  function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
      public
      override
      onlyAllowedOperator(from)
  {
      super.safeTransferFrom(from, to, tokenId, data);
  }

  function emergencyMint(uint256 quantity, address _To) external onlyOwner {
    require(totalSupply() + quantity <= collectionSize, "too many already minted");
    _safeMint(_To, quantity);
  }

  function setSigner(address signer_) external onlyOwner {
      require(signer_ != address(0), "Signer cannot be the zero address");
      signer = signer_;
  }

  function verifyRerollSignature(address walletAddress, uint256 allotmentId, uint256 reRollCost, uint256 nonce, bytes calldata signature) internal view returns (bool) {
        require(signer != address(0), "Signer not set");
        bytes32 hash = keccak256(abi.encodePacked(walletAddress, allotmentId, reRollCost, nonce));
        bytes32 signedHash = hash.toEthSignedMessageHash();

        return SignatureChecker.isValidSignatureNow(signer, signedHash, signature);
  }

  function verifyMintSignature(address walletAddress, uint256[] calldata allotmentIds, uint256 nonce, bytes calldata signature) internal view returns (bool) {
        require(signer != address(0), "Signer not set");
        bytes32 hash = keccak256(abi.encodePacked(walletAddress, allotmentIds, nonce));
        bytes32 signedHash = hash.toEthSignedMessageHash();

        return SignatureChecker.isValidSignatureNow(signer, signedHash, signature);
  }

   // Merkle leaf validator function for storing whitelists off chain saving massive gas
  function whitelistValidated(address wallet, uint256 index, uint256 amount, bytes32[] memory proof) internal view returns (bool) {

        // Compute the merkle root
        bytes32 node = keccak256(abi.encodePacked(index, wallet, amount));
        uint256 path = index;
        for (uint16 i = 0; i < proof.length; i++) {
            if ((path & 0x01) == 1) {
                node = keccak256(abi.encodePacked(proof[i], node));
            } else {
                node = keccak256(abi.encodePacked(node, proof[i]));
            }
            path /= 2;
        }

        // Check the merkle proof against the root hash array
        for(uint i = 0; i < _whitelistRootHash.length; i++)
        {
            if (node == _whitelistRootHash[i])
            {
                return true;
            }
        }

        return false;
    }

  // metadata URI
  string private _baseTokenURI;

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

  function setBaseURI(string calldata baseURI) external onlyOwner {
    _baseTokenURI = baseURI;
  }

  /*
    * @dev Withdraw all ether from this contract and send to prespecified 
    * wallets (Callable by anyone)
  */
  function withdraw() external {
      uint256 balance = address(this).balance;
      uint256 walletBalance = balance.mul(secondaryPartyFee).div(100);
      payable(payoutWallet1).transfer(walletBalance);
      payable(payoutWallet2).transfer(balance.sub(walletBalance));
  }

  /**
    * @dev Withdraw all erc20 of the signature argument address from this contract and send to prespecified 
    * wallets (Callable by anyone)
  */
  function withdrawERC20(address _token) external {
      IERC20 targetToken = IERC20(_token);
      uint256 balance = targetToken.balanceOf(address(this));
      uint256 walletBalance = balance.mul(secondaryPartyFee).div(100);
      require(balance > 0, "Nothing to withdraw");

      targetToken.transferFrom(address(this), payoutWallet1, walletBalance);
      targetToken.transferFrom(address(this), payoutWallet2, balance.sub(walletBalance));
  }

  function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
    _setOwnersExplicit(quantity);
  }

  function numberMinted(address owner) public view returns (uint256) {
    return _numberMinted(owner);
  }

  function getOwnershipData(uint256 tokenId)
    external
    view
    returns (TokenOwnership memory)
  {
    return ownershipOf(tokenId);
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"maxBatchSize_","type":"uint256"},{"internalType":"uint256","name":"collectionSize_","type":"uint256"},{"internalType":"uint256","name":"amountForWhitelistAndPublic_","type":"uint256"},{"internalType":"address","name":"ioperatorFilterRegistry_","type":"address"},{"internalType":"address","name":"subscriptionOrRegistrantToCopy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","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":false,"internalType":"uint256[]","name":"allotmentIds","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"GoldlistMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"allotmentId","type":"uint256"}],"name":"TokenReRoll","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startingTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"WhitelistMint","type":"event"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"}],"name":"addToWhitelistRootHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountForWhitelistAndPublic","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":"clearWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"address","name":"_To","type":"address"}],"name":"emergencyMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getOwnershipData","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"}],"internalType":"struct ERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"allotmentIds","type":"uint256[]"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"goldlistMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"goldlistMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goldlistStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"iOperatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"isTokenWhitelistMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerAddressDuringMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPublicMintsPerTxn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWhitelistMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextOwnerToExplicitlySet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"quantity","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicSaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"allotmentId","type":"uint256"},{"internalType":"uint256","name":"reRollCost","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"reRoll","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":[],"name":"saleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_time","type":"uint256"}],"name":"setGoldlistStartTimeExplicit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_iOperatorFilterRegistry","type":"address"}],"name":"setIOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"setOwnersExplicit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setPublicSaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_time","type":"uint256"}],"name":"setSaleStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signer_","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setWhitelistSaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_time","type":"uint256"}],"name":"setWhitelistStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"_newPayoutWallet","type":"address"},{"internalType":"bool","name":"firstWallet","type":"bool"}],"name":"updatePayoutWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newRerollPayoutWallet","type":"address"}],"name":"updateRerollPayoutWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"spotInWhitelist","type":"uint256"},{"internalType":"uint256","name":"maxMints","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistSaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000000000000000000000000000000000000000000c8000000000000000000000000000000000000000000000000000000000000270f000000000000000000000000000000000000000000000000000000000000012e000000000000000000000000000000000000aaeb6d7670e522a718067333cd4e0000000000000000000000003cc6cdda760b79bafa08df41ecfa224f810dceb6

-----Decoded View---------------
Arg [0] : maxBatchSize_ (uint256): 200
Arg [1] : collectionSize_ (uint256): 9999
Arg [2] : amountForWhitelistAndPublic_ (uint256): 302
Arg [3] : ioperatorFilterRegistry_ (address): 0x000000000000AAeB6D7670E522A718067333cd4E
Arg [4] : subscriptionOrRegistrantToCopy (address): 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c8
Arg [1] : 000000000000000000000000000000000000000000000000000000000000270f
Arg [2] : 000000000000000000000000000000000000000000000000000000000000012e
Arg [3] : 000000000000000000000000000000000000aaeb6d7670e522a718067333cd4e
Arg [4] : 0000000000000000000000003cc6cdda760b79bafa08df41ecfa224f810dceb6

Deployed Bytecode Sourcemap

66948:12496:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67772:49;;;;;;;;;;-1:-1:-1;67772:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;529:25:1;;;517:2;502:18;67772:49:0;;;;;;;;32764:370;;;;;;;;;;-1:-1:-1;32764:370:0;;;;;:::i;:::-;;:::i;:::-;;;1116:14:1;;1109:22;1091:41;;1079:2;1064:18;32764:370:0;951:187:1;34490:94:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;36023:204::-;;;;;;;;;;-1:-1:-1;36023:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2248:32:1;;;2230:51;;2218:2;2203:18;36023:204:0;2084:203:1;74761:153:0;;;;;;;;;;-1:-1:-1;74761:153:0;;;;;:::i;:::-;;:::i;:::-;;68096:54;;;;;;;;;;-1:-1:-1;68096:54:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;70439:82;;;;;;;;;;;;;:::i;69687:251::-;;;;;;;;;;-1:-1:-1;69687:251:0;;;;;:::i;:::-;;:::i;31325:94::-;;;;;;;;;;-1:-1:-1;31401:12:0;;31325:94;;70527:136;;;;;;;;;;-1:-1:-1;70527:136:0;;;;;:::i;:::-;;:::i;67494:28::-;;;;;;;;;;;;;;;;69944:225;;;;;;;;;;-1:-1:-1;69944:225:0;;;;;:::i;:::-;;:::i;67158:21::-;;;;;;;;;;-1:-1:-1;67158:21:0;;;;-1:-1:-1;;;;;67158:21:0;;;74920:159;;;;;;;;;;-1:-1:-1;74920:159:0;;;;;:::i;:::-;;:::i;71510:489::-;;;;;;:::i;:::-;;:::i;79057:118::-;;;;;;;;;;-1:-1:-1;79057:118:0;;;;;:::i;:::-;;:::i;72005:504::-;;;;;;:::i;:::-;;:::i;31956:744::-;;;;;;;;;;-1:-1:-1;31956:744:0;;;;;:::i;:::-;;:::i;78152:278::-;;;;;;;;;;;;;:::i;75085:167::-;;;;;;;;;;-1:-1:-1;75085:167:0;;;;;:::i;:::-;;:::i;75480:195::-;;;;;;;;;;-1:-1:-1;75480:195:0;;;;;:::i;:::-;;:::i;67606:29::-;;;;;;;;;;;;;;;;31488:177;;;;;;;;;;-1:-1:-1;31488:177:0;;;;;:::i;:::-;;:::i;70784:94::-;;;;;;;;;;-1:-1:-1;70784:94:0;;;;;:::i;:::-;;:::i;77922:100::-;;;;;;;;;;-1:-1:-1;77922:100:0;;;;;:::i;:::-;;:::i;52361:54::-;;;;;;;;;;-1:-1:-1;52361:54:0;;;;-1:-1:-1;;;;;52361:54:0;;;34313:118;;;;;;;;;;-1:-1:-1;34313:118:0;;;;;:::i;:::-;;:::i;75681:162::-;;;;;;;;;;-1:-1:-1;75681:162:0;;;;;:::i;:::-;;:::i;33190:211::-;;;;;;;;;;-1:-1:-1;33190:211:0;;;;;:::i;:::-;;:::i;5130:94::-;;;;;;;;;;;;;:::i;72515:715::-;;;;;;;;;;-1:-1:-1;72515:715:0;;;;;:::i;:::-;;:::i;67565:32::-;;;;;;;;;;;;;;;;74360:217;;;;;;;;;;;;;:::i;70884:99::-;;;;;;;;;;-1:-1:-1;70884:99:0;;;;;:::i;:::-;;:::i;67186:48::-;;;;;;;;;;;;;;;4479:87;;;;;;;;;;-1:-1:-1;4525:7:0;4552:6;-1:-1:-1;;;;;4552:6:0;4479:87;;70989:96;;;;;;;;;;-1:-1:-1;70989:96:0;;;;;:::i;:::-;;:::i;79294:147::-;;;;;;;;;;-1:-1:-1;79294:147:0;;;;;:::i;:::-;;:::i;:::-;;;;6425:13:1;;-1:-1:-1;;;;;6421:39:1;6403:58;;6521:4;6509:17;;;6503:24;-1:-1:-1;;;;;6499:49:1;6477:20;;;6470:79;;;;6376:18;79294:147:0;6193:362:1;67527:33:0;;;;;;;;;;;;;;;;34645:98;;;;;;;;;;;;;:::i;70669:109::-;;;;;;;;;;-1:-1:-1;70669:109:0;;;;;:::i;:::-;;:::i;74583:172::-;;;;;;;;;;-1:-1:-1;74583:172:0;;;;;:::i;:::-;;:::i;70323:110::-;;;;;;;;;;-1:-1:-1;70323:110:0;;;;;:::i;:::-;;:::i;70175:142::-;;;;;;;;;;-1:-1:-1;70175:142:0;;;;;:::i;:::-;;:::i;67991:47::-;;;;;;;;;;-1:-1:-1;67991:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;75258:216;;;;;;;;;;-1:-1:-1;75258:216:0;;;;;:::i;:::-;;:::i;67640:32::-;;;;;;;;;;;;;;;;34806:394;;;;;;;;;;-1:-1:-1;34806:394:0;;;;;:::i;:::-;;:::i;41746:43::-;;;;;;;;;;;;;;;;79181:107;;;;;;;;;;-1:-1:-1;79181:107:0;;;;;:::i;:::-;;:::i;73236:906::-;;;;;;:::i;:::-;;:::i;67335:35::-;;;;;;;;;;;;;;;;36636:186;;;;;;;;;;-1:-1:-1;36636:186:0;;;;;:::i;:::-;-1:-1:-1;;;;;36781:25:0;;;36758:4;36781:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;36636:186;5379:192;;;;;;;;;;-1:-1:-1;5379:192:0;;;;;:::i;:::-;;:::i;67883:48::-;;;;;;;;;;-1:-1:-1;67883:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;78595:456;;;;;;;;;;-1:-1:-1;78595:456:0;;;;;:::i;:::-;;:::i;67298:32::-;;;;;;;;;;;;;;;;67239:52;;;;;;;;;;;;;;;32764:370;32891:4;-1:-1:-1;;;;;;32921:40:0;;-1:-1:-1;;;32921:40:0;;:99;;-1:-1:-1;;;;;;;32972:48:0;;-1:-1:-1;;;32972:48:0;32921:99;:160;;;-1:-1:-1;;;;;;;33031:50:0;;-1:-1:-1;;;33031:50:0;32921:160;:207;;;-1:-1:-1;;;;;;;;;;21960:40:0;;;33092:36;32907:221;32764:370;-1:-1:-1;;32764:370:0:o;34490:94::-;34544:13;34573:5;34566:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34490:94;:::o;36023:204::-;36091:7;36115:16;36123:7;37967:12;;-1:-1:-1;37957:22:0;37880:105;36115:16;36107:74;;;;-1:-1:-1;;;36107:74:0;;10150:2:1;36107:74:0;;;10132:21:1;10189:2;10169:18;;;10162:30;10228:34;10208:18;;;10201:62;-1:-1:-1;;;10279:18:1;;;10272:43;10332:19;;36107:74:0;;;;;;;;;-1:-1:-1;36197:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;36197:24:0;;36023:204::o;74761:153::-;74857:8;54050:30;54071:8;54050:20;:30::i;:::-;74876:32:::1;74890:8;74900:7;74876:13;:32::i;:::-;74761:153:::0;;;:::o;70439:82::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70490:25:::1;70497:18;;70490:25;:::i;:::-;70439:82::o:0;69687:251::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;69783:23:::1;:75:::0;;-1:-1:-1;;;;;;69783:75:0::1;-1:-1:-1::0;;;;;69783:75:0;::::1;::::0;;::::1;::::0;;;69870:62:::1;::::0;2230:51:1;;;69870:62:0::1;::::0;2218:2:1;2203:18;69870:62:0::1;;;;;;;69687:251:::0;:::o;70527:136::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70599:18:::1;:26:::0;;;70632:17:::1;:25:::0;70527:136::o;69944:225::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70044:11:::1;70041:123;;;70065:13;:32:::0;;-1:-1:-1;;;;;70065:32:0;::::1;-1:-1:-1::0;;;;;;70065:32:0;;::::1;;::::0;;69944:225;;:::o;70041:123::-:1;70124:13;:32:::0;;-1:-1:-1;;;;;;70124:32:0::1;-1:-1:-1::0;;;;;70124:32:0;::::1;;::::0;;70041:123:::1;69944:225:::0;;:::o;74920:159::-;75021:4;-1:-1:-1;;;;;53776:18:0;;53784:10;53776:18;53772:83;;53811:32;53832:10;53811:20;:32::i;:::-;75036:37:::1;75055:4;75061:2;75065:7;75036:18;:37::i;:::-;74920:159:::0;;;;:::o;71510:489::-;71640:76;71662:10;71674:11;71687:10;71699:5;71706:9;;71640:21;:76::i;:::-;71632:109;;;;-1:-1:-1;;;71632:109:0;;10925:2:1;71632:109:0;;;10907:21:1;10964:2;10944:18;;;10937:30;-1:-1:-1;;;10983:18:1;;;10976:50;11043:18;;71632:109:0;10723:344:1;71632:109:0;71769:10;71756:24;;;;:12;:24;;;;;;:33;;71748:61;;;;-1:-1:-1;;;71748:61:0;;11274:2:1;71748:61:0;;;11256:21:1;11313:2;11293:18;;;11286:30;-1:-1:-1;;;11332:18:1;;;11325:45;11387:18;;71748:61:0;11072:339:1;71748:61:0;71816:24;71829:10;71816:12;:24::i;:::-;71887:10;71874:24;;;;:12;:24;;;;;;:28;;71901:1;71874:28;:::i;:::-;71860:10;71847:24;;;;:12;:24;;;;;;:55;;;;71917:18;;71909:48;;-1:-1:-1;;;;;71917:18:0;;;;71909:48;;;;;;;;;71847:24;71909:48;;71917:18;71909:48;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71969:24:0;;71981:11;;71969:24;;;;;71510:489;;;;;:::o;79057:118::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;19454:1:::1;20050:7;;:19:::0;20042:63:::1;;;::::0;-1:-1:-1;;;20042:63:0;;11880:2:1;20042:63:0::1;::::0;::::1;11862:21:1::0;11919:2;11899:18;;;11892:30;11958:33;11938:18;;;11931:61;12009:18;;20042:63:0::1;11678:355:1::0;20042:63:0::1;19454:1;20183:7;:18:::0;79141:28:::2;79160:8:::0;79141:18:::2;:28::i;:::-;-1:-1:-1::0;19410:1:0::1;20362:7;:22:::0;79057:118::o;72005:504::-;72075:13;;:18;;;;:54;;;72116:13;;72097:15;:32;;72075:54;72067:91;;;;-1:-1:-1;;;72067:91:0;;12240:2:1;72067:91:0;;;12222:21:1;12279:2;12259:18;;;12252:30;12318:26;12298:18;;;12291:54;12362:18;;72067:91:0;12038:348:1;72067:91:0;72201:27;72189:8;72173:13;31401:12;;;31325:94;72173:13;:24;;;;:::i;:::-;:55;;72165:119;;;;-1:-1:-1;;;72165:119:0;;12593:2:1;72165:119:0;;;12575:21:1;12632:2;12612:18;;;12605:30;12671:34;12651:18;;;12644:62;-1:-1:-1;;;12722:18:1;;;12715:49;12781:19;;72165:119:0;12391:415:1;72165:119:0;72310:20;;72299:8;:31;72291:88;;;;-1:-1:-1;;;72291:88:0;;13013:2:1;72291:88:0;;;12995:21:1;13052:2;13032:18;;;13025:30;13091:34;13071:18;;;13064:62;-1:-1:-1;;;13142:18:1;;;13135:42;13194:19;;72291:88:0;12811:408:1;72291:88:0;72388:17;72425:8;72408:14;;:25;;;;:::i;:::-;72388:45;-1:-1:-1;72440:33:0;722:10;72450:12;72464:8;72440:9;:33::i;:::-;72480:23;72493:9;72480:12;:23::i;31956:744::-;32065:7;32100:16;32110:5;32100:9;:16::i;:::-;32092:5;:24;32084:71;;;;-1:-1:-1;;;32084:71:0;;13599:2:1;32084:71:0;;;13581:21:1;13638:2;13618:18;;;13611:30;13677:34;13657:18;;;13650:62;-1:-1:-1;;;13728:18:1;;;13721:32;13770:19;;32084:71:0;13397:398:1;32084:71:0;32162:22;32187:13;31401:12;;;31325:94;32187:13;32162:38;;32207:19;32237:25;32287:9;32282:350;32306:14;32302:1;:18;32282:350;;;32336:31;32370:14;;;:11;:14;;;;;;;;;32336:48;;;;;;;;;-1:-1:-1;;;;;32336:48:0;;;;;-1:-1:-1;;;32336:48:0;;;-1:-1:-1;;;;;32336:48:0;;;;;;;;32397:28;32393:89;;32458:14;;;-1:-1:-1;32393:89:0;32515:5;-1:-1:-1;;;;;32494:26:0;:17;-1:-1:-1;;;;;32494:26:0;;32490:135;;32552:5;32537:11;:20;32533:59;;-1:-1:-1;32579:1:0;-1:-1:-1;32572:8:0;;-1:-1:-1;;;32572:8:0;32533:59;32602:13;;;;:::i;:::-;;;;32490:135;-1:-1:-1;32322:3:0;;;;:::i;:::-;;;;32282:350;;;-1:-1:-1;32638:56:0;;-1:-1:-1;;;32638:56:0;;14142:2:1;32638:56:0;;;14124:21:1;14181:2;14161:18;;;14154:30;14220:34;14200:18;;;14193:62;-1:-1:-1;;;14271:18:1;;;14264:44;14325:19;;32638:56:0;13940:410:1;78152:278:0;78190:15;78208:21;78190:39;;78238:21;78262:39;78297:3;78262:30;78274:17;;78262:7;:11;;:30;;;;:::i;:::-;:34;;:39::i;:::-;78318:13;;78310:46;;78238:63;;-1:-1:-1;;;;;;78318:13:0;;78310:46;;;;;78238:63;;78318:13;78310:46;78318:13;78310:46;78238:63;78318:13;78310:46;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78373:13:0;;-1:-1:-1;;;;;78373:13:0;78365:59;78397:26;:7;78409:13;78397:11;:26::i;:::-;78365:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75085:167;75190:4;-1:-1:-1;;;;;53776:18:0;;53784:10;53776:18;53772:83;;53811:32;53832:10;53811:20;:32::i;:::-;75205:41:::1;75228:4;75234:2;75238:7;75205:22;:41::i;75480:195::-:0;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;75596:14:::1;75584:8;75568:13;31401:12:::0;;;31325:94;75568:13:::1;:24;;;;:::i;:::-;:42;;75560:78;;;::::0;-1:-1:-1;;;75560:78:0;;14557:2:1;75560:78:0::1;::::0;::::1;14539:21:1::0;14596:2;14576:18;;;14569:30;14635:25;14615:18;;;14608:53;14678:18;;75560:78:0::1;14355:347:1::0;75560:78:0::1;75645:24;75655:3;75660:8;75645:9;:24::i;31488:177::-:0;31555:7;31587:13;31401:12;;;31325:94;31587:13;31579:5;:21;31571:69;;;;-1:-1:-1;;;31571:69:0;;14909:2:1;31571:69:0;;;14891:21:1;14948:2;14928:18;;;14921:30;14987:34;14967:18;;;14960:62;-1:-1:-1;;;15038:18:1;;;15031:33;15081:19;;31571:69:0;14707:399:1;31571:69:0;-1:-1:-1;31654:5:0;31488:177::o;70784:94::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70851:13:::1;:21:::0;70784:94::o;77922:100::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;77993:13:::1;:23;78009:7:::0;;77993:13;:23:::1;:::i;34313:118::-:0;34377:7;34400:20;34412:7;34400:11;:20::i;:::-;:25;;34313:118;-1:-1:-1;;34313:118:0:o;75681:162::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;75753:21:0;::::1;75745:67;;;::::0;-1:-1:-1;;;75745:67:0;;17371:2:1;75745:67:0::1;::::0;::::1;17353:21:1::0;17410:2;17390:18;;;17383:30;17449:34;17429:18;;;17422:62;-1:-1:-1;;;17500:18:1;;;17493:31;17541:19;;75745:67:0::1;17169:397:1::0;75745:67:0::1;75821:6;:16:::0;;-1:-1:-1;;;;;;75821:16:0::1;-1:-1:-1::0;;;;;75821:16:0;;;::::1;::::0;;;::::1;::::0;;75681:162::o;33190:211::-;33254:7;-1:-1:-1;;;;;33278:19:0;;33270:75;;;;-1:-1:-1;;;33270:75:0;;17773:2:1;33270:75:0;;;17755:21:1;17812:2;17792:18;;;17785:30;17851:34;17831:18;;;17824:62;-1:-1:-1;;;17902:18:1;;;17895:41;17953:19;;33270:75:0;17571:407:1;33270:75:0;-1:-1:-1;;;;;;33367:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;33367:27:0;;33190:211::o;5130:94::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;5195:21:::1;5213:1;5195:9;:21::i;72515:715::-:0;72646:12;72682:63;72702:10;72646:12;;72728:5;72735:9;;72682:19;:63::i;:::-;72674:93;;;;-1:-1:-1;;;72674:93:0;;18185:2:1;72674:93:0;;;18167:21:1;18224:2;18204:18;;;18197:30;-1:-1:-1;;;18243:18:1;;;18236:47;18300:18;;72674:93:0;17983:341:1;72674:93:0;72795:10;72782:24;;;;:12;:24;;;;;;:33;;72774:61;;;;-1:-1:-1;;;72774:61:0;;11274:2:1;72774:61:0;;;11256:21:1;11313:2;11293:18;;;11286:30;-1:-1:-1;;;11332:18:1;;;11325:45;11387:18;;72774:61:0;11072:339:1;72774:61:0;72850:17;;:22;;;;:62;;;72895:17;;72876:15;:36;;72850:62;72842:103;;;;-1:-1:-1;;;72842:103:0;;18531:2:1;72842:103:0;;;18513:21:1;18570:2;18550:18;;;18543:30;18609;18589:18;;;18582:58;18657:18;;72842:103:0;18329:352:1;72842:103:0;72954:25;72982:42;73000:13;31401:12;;;31325:94;73000:13;73015:8;72982:17;:42::i;:::-;72954:70;-1:-1:-1;73033:33:0;722:10;73043:12;642:98;73033:33;722:10;73075:27;;;;:13;:27;;;;;:39;;73106:8;;73075:27;:39;;73106:8;;73075:39;:::i;:::-;;;;-1:-1:-1;;73161:10:0;73148:24;;;;:12;:24;;;;;;:28;;73175:1;73148:28;:::i;:::-;73134:10;73121:24;;;;:12;:24;;;;;;;:55;;;;73188:36;;;;;73201:12;;;;73215:8;;73188:36;:::i;:::-;;;;;;;;72620:610;;72515:715;;;;;:::o;74360:217::-;74407:7;74426:13;;74443:1;74426:18;;:54;;;;;74467:13;;74448:15;:32;;74426:54;74423:149;;;-1:-1:-1;74498:14:0;;;74360:217::o;74423:149::-;-1:-1:-1;74547:17:0;;;74360:217::o;70884:99::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70952:17:::1;:25:::0;70884:99::o;70989:96::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;71057:14:::1;:22:::0;70989:96::o;79294:147::-;-1:-1:-1;;;;;;;;;;;;;;;;;79415:20:0;79427:7;79415:11;:20::i;34645:98::-;34701:13;34730:7;34723:14;;;;;:::i;70669:109::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70747:17:::1;:25:::0;70669:109::o;74583:172::-;74687:8;54050:30;54071:8;54050:20;:30::i;:::-;74706:43:::1;74730:8;74740;74706:23;:43::i;70323:110::-:0;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70397:18:::1;:30:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;70397:30:0;;;;;::::1;::::0;70323:110::o;70175:142::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;70268:18:::1;:43:::0;;-1:-1:-1;;;;;;70268:43:0::1;-1:-1:-1::0;;;;;70268:43:0;;;::::1;::::0;;;::::1;::::0;;70175:142::o;75258:216::-;75403:4;-1:-1:-1;;;;;53776:18:0;;53784:10;53776:18;53772:83;;53811:32;53832:10;53811:20;:32::i;:::-;75421:47:::1;75444:4;75450:2;75454:7;75463:4;75421:22;:47::i;:::-;75258:216:::0;;;;;:::o;34806:394::-;34904:13;34945:16;34953:7;37967:12;;-1:-1:-1;37957:22:0;37880:105;34945:16;34929:97;;;;-1:-1:-1;;;34929:97:0;;19901:2:1;34929:97:0;;;19883:21:1;19940:2;19920:18;;;19913:30;19979:34;19959:18;;;19952:62;-1:-1:-1;;;20030:18:1;;;20023:45;20085:19;;34929:97:0;19699:411:1;34929:97:0;35035:21;35059:10;:8;:10::i;:::-;35035:34;;35114:1;35096:7;35090:21;:25;:104;;;;;;;;;;;;;;;;;35151:7;35160:18;:7;:16;:18::i;:::-;35134:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;35090:104;35076:118;34806:394;-1:-1:-1;;;34806:394:0:o;79181:107::-;79239:7;79262:20;79276:5;79262:13;:20::i;73236:906::-;73376:66;722:10;73409:15;73426:8;73436:5;73376:18;:66::i;:::-;73368:106;;;;-1:-1:-1;;;73368:106:0;;20818:2:1;73368:106:0;;;20800:21:1;20857:2;20837:18;;;20830:30;20896:29;20876:18;;;20869:57;20943:18;;73368:106:0;20616:351:1;73368:106:0;73489:18;;:23;;;;:64;;;73535:18;;73516:15;:37;;73489:64;73481:105;;;;-1:-1:-1;;;73481:105:0;;18531:2:1;73481:105:0;;;18513:21:1;18570:2;18550:18;;;18543:30;18609;18589:18;;;18582:58;18657:18;;73481:105:0;18329:352:1;73481:105:0;73629:27;73617:8;73601:13;31401:12;;;31325:94;73601:13;:24;;;;:::i;:::-;:55;;73593:142;;;;-1:-1:-1;;;73593:142:0;;21174:2:1;73593:142:0;;;21156:21:1;21213:2;21193:18;;;21186:30;21252:34;21232:18;;;21225:62;21323:34;21303:18;;;21296:62;-1:-1:-1;;;21374:19:1;;;21367:41;21425:19;;73593:142:0;20972:478:1;73593:142:0;73793:17;;722:10;73750:28;;;;:14;:28;;;;;;:39;;73781:8;;73750:39;:::i;:::-;:60;;73742:110;;;;-1:-1:-1;;;73742:110:0;;21657:2:1;73742:110:0;;;21639:21:1;21696:2;21676:18;;;21669:30;21735:34;21715:18;;;21708:62;-1:-1:-1;;;21786:18:1;;;21779:35;21831:19;;73742:110:0;21455:401:1;73742:110:0;73861:20;73884:13;31401:12;;;31325:94;73884:13;73904:36;;;;:22;:36;;;;;:43;;-1:-1:-1;;73904:43:0;73943:4;73904:43;;;73861:36;;-1:-1:-1;73988:8:0;;73956:14;;73971:12;722:10;;642:98;73971:12;-1:-1:-1;;;;;73956:28:0;-1:-1:-1;;;;;73956:28:0;;;;;;;;;;;;;:40;;;;;;;:::i;:::-;;;;-1:-1:-1;74005:33:0;;-1:-1:-1;722:10:0;74029:8;74005:9;:33::i;:::-;74045:42;74078:8;74058:17;;:28;;;;:::i;:::-;74045:12;:42::i;:::-;74099:37;;;22035:25:1;;;22091:2;22076:18;;22069:34;;;74099:37:0;;22008:18:1;74099:37:0;;;;;;;73361:781;73236:906;;;;:::o;5379:192::-;4525:7;4552:6;-1:-1:-1;;;;;4552:6:0;722:10;4699:23;4691:68;;;;-1:-1:-1;;;4691:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;5468:22:0;::::1;5460:73;;;::::0;-1:-1:-1;;;5460:73:0;;22316:2:1;5460:73:0::1;::::0;::::1;22298:21:1::0;22355:2;22335:18;;;22328:30;22394:34;22374:18;;;22367:62;-1:-1:-1;;;22445:18:1;;;22438:36;22491:19;;5460:73:0::1;22114:402:1::0;5460:73:0::1;5544:19;5554:8;5544:9;:19::i;:::-;5379:192:::0;:::o;78595:456::-;78714:36;;-1:-1:-1;;;78714:36:0;;78744:4;78714:36;;;2230:51:1;78680:6:0;;78652:18;;-1:-1:-1;;;;;78714:21:0;;;;;2203:18:1;;78714:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78696:54;;78759:21;78783:39;78818:3;78783:30;78795:17;;78783:7;:11;;:30;;;;:::i;:39::-;78759:63;;78849:1;78839:7;:11;78831:43;;;;-1:-1:-1;;;78831:43:0;;22912:2:1;78831:43:0;;;22894:21:1;22951:2;22931:18;;;22924:30;-1:-1:-1;;;22970:18:1;;;22963:49;23029:18;;78831:43:0;22710:343:1;78831:43:0;78925:13;;78885:69;;-1:-1:-1;;;78885:69:0;;78918:4;78885:69;;;23298:34:1;-1:-1:-1;;;;;78925:13:0;;;23348:18:1;;;23341:43;23400:18;;;23393:34;;;78885:24:0;;;;;;23233:18:1;;78885:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;79003:13:0;;-1:-1:-1;;;;;78963:24:0;;;;;;78996:4;;79003:13;79018:26;:7;79030:13;79018:11;:26::i;:::-;78963:82;;-1:-1:-1;;;;;;78963:82:0;;;;;;;-1:-1:-1;;;;;23316:15:1;;;78963:82:0;;;23298:34:1;23368:15;;;;23348:18;;;23341:43;23400:18;;;23393:34;23233:18;;78963:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;54193:645::-;54392:23;;-1:-1:-1;;;;;54392:23:0;54384:44;:48;54380:451;;54682:23;;:66;;-1:-1:-1;;;54682:66:0;;54732:4;54682:66;;;23900:34:1;-1:-1:-1;;;;;23970:15:1;;;23950:18;;;23943:43;54682:23:0;;;;:41;;23835:18:1;;54682:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54677:143;;54776:28;;-1:-1:-1;;;54776:28:0;;-1:-1:-1;;;;;2248:32:1;;54776:28:0;;;2230:51:1;2203:18;;54776:28:0;2084:203:1;35578:387:0;35655:13;35671:24;35687:7;35671:15;:24::i;:::-;35655:40;;35716:5;-1:-1:-1;;;;;35710:11:0;:2;-1:-1:-1;;;;;35710:11:0;;35702:58;;;;-1:-1:-1;;;35702:58:0;;24199:2:1;35702:58:0;;;24181:21:1;24238:2;24218:18;;;24211:30;24277:34;24257:18;;;24250:62;-1:-1:-1;;;24328:18:1;;;24321:32;24370:19;;35702:58:0;23997:398:1;35702:58:0;722:10;-1:-1:-1;;;;;35785:21:0;;;;:62;;-1:-1:-1;35810:37:0;35827:5;722:10;36636:186;:::i;35810:37::-;35769:153;;;;-1:-1:-1;;;35769:153:0;;24602:2:1;35769:153:0;;;24584:21:1;24641:2;24621:18;;;24614:30;24680:34;24660:18;;;24653:62;24751:27;24731:18;;;24724:55;24796:19;;35769:153:0;24400:421:1;35769:153:0;35931:28;35940:2;35944:7;35953:5;35931:8;:28::i;36881:150::-;36997:28;37007:4;37013:2;37017:7;36997:9;:28::i;75849:477::-;76033:6;;76008:4;;-1:-1:-1;;;;;76033:6:0;76025:47;;;;-1:-1:-1;;;76025:47:0;;25028:2:1;76025:47:0;;;25010:21:1;25067:2;25047:18;;;25040:30;-1:-1:-1;;;25086:18:1;;;25079:44;25140:18;;76025:47:0;24826:338:1;76025:47:0;76108:63;;-1:-1:-1;;;;;;25402:2:1;25398:15;;;25394:53;76108:63:0;;;25382:66:1;25464:12;;;25457:28;;;25501:12;;;25494:28;;;25538:12;;;25531:28;;;76083:12:0;;25575:13:1;;76108:63:0;;;;;;;;;;;;;76098:74;;;;;;76083:89;;76183:18;76204:29;:4;62343:34;62138:15;62330:48;;;62399:4;62392:18;;;;62451:4;62435:21;;;62069:405;76204:29;76290:6;;76253:67;;;;;;;;;;;;;;;;;;;;;;76183:50;;-1:-1:-1;76253:67:0;;-1:-1:-1;;;;;76290:6:0;;;;76183:50;;76310:9;;;;;;76253:67;;76310:9;;;;76253:67;;;;;;;;;-1:-1:-1;76253:36:0;;-1:-1:-1;;;76253:67:0:i;:::-;76246:74;75849:477;-1:-1:-1;;;;;;;;;75849:477:0:o;74148:206::-;74221:5;74208:9;:18;;74200:53;;;;-1:-1:-1;;;74200:53:0;;25801:2:1;74200:53:0;;;25783:21:1;25840:2;25820:18;;;25813:30;-1:-1:-1;;;25859:18:1;;;25852:52;25921:18;;74200:53:0;25599:346:1;74200:53:0;74276:5;74264:9;:17;74260:89;;;722:10;74292:49;74323:17;74335:5;74323:9;:17;:::i;:::-;74292:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41894:846;41984:24;;42023:12;42015:49;;;;-1:-1:-1;;;42015:49:0;;26285:2:1;42015:49:0;;;26267:21:1;26324:2;26304:18;;;26297:30;26363:26;26343:18;;;26336:54;26407:18;;42015:49:0;26083:348:1;42015:49:0;42071:16;42121:1;42090:28;42110:8;42090:17;:28;:::i;:::-;:32;;;;:::i;:::-;42071:51;-1:-1:-1;42144:18:0;42161:1;42144:14;:18;:::i;:::-;42133:8;:29;42129:81;;;42184:18;42201:1;42184:14;:18;:::i;:::-;42173:29;;42129:81;42325:17;42333:8;37967:12;;-1:-1:-1;37957:22:0;37880:105;42325:17;42317:68;;;;-1:-1:-1;;;42317:68:0;;26638:2:1;42317:68:0;;;26620:21:1;26677:2;26657:18;;;26650:30;26716:34;26696:18;;;26689:62;-1:-1:-1;;;26767:18:1;;;26760:36;26813:19;;42317:68:0;26436:402:1;42317:68:0;42409:17;42392:297;42433:8;42428:1;:13;42392:297;;42492:1;42461:14;;;:11;:14;;;;;:19;-1:-1:-1;;;;;42461:19:0;42457:225;;42507:31;42541:14;42553:1;42541:11;:14::i;:::-;42583:89;;;;;;;;42610:14;;-1:-1:-1;;;;;42583:89:0;;;;;;42637:24;;;;-1:-1:-1;;;;;42583:89:0;;;;;;;;;-1:-1:-1;42566:14:0;;;:11;:14;;;;;;;:106;;;;;;;;;-1:-1:-1;;;42566:106:0;-1:-1:-1;;;;;;42566:106:0;;;;;;;;;;;;-1:-1:-1;42457:225:0;42443:3;;;;:::i;:::-;;;;42392:297;;;-1:-1:-1;42722:12:0;:8;42733:1;42722:12;:::i;:::-;42695:24;:39;-1:-1:-1;;;41894:846:0:o;37991:98::-;38056:27;38066:2;38070:8;38056:27;;;;;;;;;;;;:9;:27::i;16945:220::-;17003:7;17027:1;17032;17027:6;17023:20;;-1:-1:-1;17042:1:0;17035:8;;17023:20;17054:9;17066:5;17070:1;17066;:5;:::i;:::-;17054:17;-1:-1:-1;17099:1:0;17090:5;17094:1;17054:17;17090:5;:::i;:::-;:10;17082:56;;;;-1:-1:-1;;;17082:56:0;;27302:2:1;17082:56:0;;;27284:21:1;27341:2;27321:18;;;27314:30;27380:34;27360:18;;;27353:62;-1:-1:-1;;;27431:18:1;;;27424:31;27472:19;;17082:56:0;27100:397:1;17643:153:0;17701:7;17733:1;17729;:5;17721:44;;;;-1:-1:-1;;;17721:44:0;;27704:2:1;17721:44:0;;;27686:21:1;27743:2;27723:18;;;27716:30;27782:28;27762:18;;;27755:56;27828:18;;17721:44:0;27502:350:1;17721:44:0;17783:5;17787:1;17783;:5;:::i;16528:158::-;16586:7;16619:1;16614;:6;;16606:49;;;;-1:-1:-1;;;16606:49:0;;28059:2:1;16606:49:0;;;28041:21:1;28098:2;28078:18;;;28071:30;28137:32;28117:18;;;28110:60;28187:18;;16606:49:0;27857:354:1;16606:49:0;16673:5;16677:1;16673;:5;:::i;37094:165::-;37214:39;37231:4;37237:2;37241:7;37214:39;;;;;;;;;;;;:16;:39::i;33653:606::-;-1:-1:-1;;;;;;;;;;;;;;;;;33770:16:0;33778:7;37967:12;;-1:-1:-1;37957:22:0;37880:105;33770:16;33762:71;;;;-1:-1:-1;;;33762:71:0;;28418:2:1;33762:71:0;;;28400:21:1;28457:2;28437:18;;;28430:30;28496:34;28476:18;;;28469:62;-1:-1:-1;;;28547:18:1;;;28540:40;28597:19;;33762:71:0;28216:406:1;33762:71:0;33842:26;33890:12;33879:7;:23;33875:93;;33934:22;33944:12;33934:7;:22;:::i;:::-;:26;;33959:1;33934:26;:::i;:::-;33913:47;;33875:93;33996:7;33976:212;34013:18;34005:4;:26;33976:212;;34050:31;34084:17;;;:11;:17;;;;;;;;;34050:51;;;;;;;;;-1:-1:-1;;;;;34050:51:0;;;;;-1:-1:-1;;;34050:51:0;;;-1:-1:-1;;;;;34050:51:0;;;;;;;;34114:28;34110:71;;34162:9;33653:606;-1:-1:-1;;;;33653:606:0:o;34110:71::-;-1:-1:-1;34033:6:0;;;;:::i;:::-;;;;33976:212;;;-1:-1:-1;34196:57:0;;-1:-1:-1;;;34196:57:0;;28970:2:1;34196:57:0;;;28952:21:1;29009:2;28989:18;;;28982:30;29048:34;29028:18;;;29021:62;-1:-1:-1;;;29099:18:1;;;29092:45;29154:19;;34196:57:0;28768:411:1;5579:173:0;5635:16;5654:6;;-1:-1:-1;;;;;5671:17:0;;;-1:-1:-1;;;;;;5671:17:0;;;;;;5704:40;;5654:6;;;;;;;5704:40;;5635:16;5704:40;5624:128;5579:173;:::o;76332:456::-;76506:6;;76481:4;;-1:-1:-1;;;;;76506:6:0;76498:47;;;;-1:-1:-1;;;76498:47:0;;25028:2:1;76498:47:0;;;25010:21:1;25067:2;25047:18;;;25040:30;-1:-1:-1;;;25086:18:1;;;25079:44;25140:18;;76498:47:0;24826:338:1;76498:47:0;76556:12;76598:13;76613:12;;76627:5;76581:52;;;;;;;;;;;:::i;71091:413::-;71182:16;71261:25;71303:8;-1:-1:-1;;;;;71289:23:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71289:23:0;;71261:51;;71385:9;71380:93;71404:8;71400:1;:12;71380:93;;;71446:17;71462:1;71446:13;:17;:::i;:::-;71432:8;71441:1;71432:11;;;;;;;;:::i;:::-;;;;;;;;;;:31;71414:3;;;;:::i;:::-;;;;71380:93;;;-1:-1:-1;71490:8:0;71091:413;-1:-1:-1;;;71091:413:0:o;36291:282::-;722:10;-1:-1:-1;;;;;36390:24:0;;;36382:63;;;;-1:-1:-1;;;36382:63:0;;30086:2:1;36382:63:0;;;30068:21:1;30125:2;30105:18;;;30098:30;30164:28;30144:18;;;30137:56;30210:18;;36382:63:0;29884:350:1;36382:63:0;722:10;36454:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;36454:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;36454:53:0;;;;;;;;;;36519:48;;1091:41:1;;;36454:42:0;;722:10;36519:48;;1064:18:1;36519:48:0;;;;;;;36291:282;;:::o;37322:319::-;37467:28;37477:4;37483:2;37487:7;37467:9;:28::i;:::-;37518:48;37541:4;37547:2;37551:7;37560:5;37518:22;:48::i;:::-;37502:133;;;;-1:-1:-1;;;37502:133:0;;;;;;;:::i;77808:108::-;77868:13;77897;77890:20;;;;;:::i;13780:723::-;13836:13;14057:5;14066:1;14057:10;14053:53;;-1:-1:-1;;14084:10:0;;;;;;;;;;;;-1:-1:-1;;;14084:10:0;;;;;13780:723::o;14053:53::-;14131:5;14116:12;14172:78;14179:9;;14172:78;;14205:8;;;;:::i;:::-;;-1:-1:-1;14228:10:0;;-1:-1:-1;14236:2:0;14228:10;;:::i;:::-;;;14172:78;;;14260:19;14292:6;-1:-1:-1;;;;;14282:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14282:17:0;;14260:39;;14310:154;14317:10;;14310:154;;14344:11;14354:1;14344:11;;:::i;:::-;;-1:-1:-1;14413:10:0;14421:2;14413:5;:10;:::i;:::-;14400:24;;:2;:24;:::i;:::-;14387:39;;14370:6;14377;14370:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;14370:56:0;;;;;;;;-1:-1:-1;14441:11:0;14450:2;14441:11;;:::i;:::-;;;14310:154;;;14488:6;13780:723;-1:-1:-1;;;;13780:723:0:o;33407:240::-;33468:7;-1:-1:-1;;;;;33500:19:0;;33484:102;;;;-1:-1:-1;;;33484:102:0;;30978:2:1;33484:102:0;;;30960:21:1;31017:2;30997:18;;;30990:30;31056:34;31036:18;;;31029:62;-1:-1:-1;;;31107:18:1;;;31100:47;31164:19;;33484:102:0;30776:413:1;33484:102:0;-1:-1:-1;;;;;;33608:19:0;;;;;:12;:19;;;;;:32;-1:-1:-1;;;33608:32:0;;-1:-1:-1;;;;;33608:32:0;;33407:240::o;76884:864::-;77006:4;77061:12;77103:5;77110:6;77118;77086:39;;;;;;;;;31379:19:1;;;31436:2;31432:15;;;;-1:-1:-1;;;;;;31428:53:1;31423:2;31414:12;;31407:75;31507:2;31498:12;;31491:28;31544:2;31535:12;;31194:359;77086:39:0;;;;-1:-1:-1;;77086:39:0;;;;;;;;;77076:50;;77086:39;77076:50;;;;;-1:-1:-1;77152:5:0;77137:12;77168:292;77191:5;:12;77187:1;:16;;;77168:292;;;77230:4;77237;77230:11;77246:1;77229:18;77225:200;;77302:5;77308:1;77302:8;;;;;;;;;;:::i;:::-;;;;;;;77312:4;77285:32;;;;;;;;31715:19:1;;;31759:2;31750:12;;31743:28;31796:2;31787:12;;31558:247;77285:32:0;;;;;;;;;;;;;77275:43;;;;;;77268:50;;77225:200;;;77393:4;77399:5;77405:1;77399:8;;;;;;;;;;:::i;:::-;;;;;;;77376:32;;;;;;;;31715:19:1;;;31759:2;31750:12;;31743:28;31796:2;31787:12;;31558:247;77376:32:0;;;;;;;;;;;;;77366:43;;;;;;77359:50;;77225:200;77439:9;77447:1;77439:9;;:::i;:::-;;-1:-1:-1;77205:3:0;;;;:::i;:::-;;;;77168:292;;;;77539:6;77535:181;77555:18;:25;77551:29;;77535:181;;;77623:18;77642:1;77623:21;;;;;;;;:::i;:::-;;;;;;;;;77615:4;:29;77611:94;;77685:4;77678:11;;;;;;;77611:94;77582:3;;;;:::i;:::-;;;;77535:181;;;-1:-1:-1;77735:5:0;;76884:864;-1:-1:-1;;;;;;;76884:864:0:o;41568:172::-;41665:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;41665:29:0;-1:-1:-1;;;;;41665:29:0;;;;;;;;;41706:28;;41665:24;;41706:28;;;;;;;41568:172;;;:::o;39933:1529::-;40030:35;40068:20;40080:7;40068:11;:20::i;:::-;40139:18;;40030:58;;-1:-1:-1;40097:22:0;;-1:-1:-1;;;;;40123:34:0;722:10;-1:-1:-1;;;;;40123:34:0;;:81;;;-1:-1:-1;722:10:0;40168:20;40180:7;40168:11;:20::i;:::-;-1:-1:-1;;;;;40168:36:0;;40123:81;:142;;;-1:-1:-1;40232:18:0;;40215:50;;722:10;36636:186;:::i;40215:50::-;40097:169;;40291:17;40275:101;;;;-1:-1:-1;;;40275:101:0;;32214:2:1;40275:101:0;;;32196:21:1;32253:2;32233:18;;;32226:30;32292:34;32272:18;;;32265:62;-1:-1:-1;;;32343:18:1;;;32336:48;32401:19;;40275:101:0;32012:414:1;40275:101:0;40423:4;-1:-1:-1;;;;;40401:26:0;:13;:18;;;-1:-1:-1;;;;;40401:26:0;;40385:98;;;;-1:-1:-1;;;40385:98:0;;32633:2:1;40385:98:0;;;32615:21:1;32672:2;32652:18;;;32645:30;32711:34;32691:18;;;32684:62;-1:-1:-1;;;32762:18:1;;;32755:36;32808:19;;40385:98:0;32431:402:1;40385:98:0;-1:-1:-1;;;;;40498:16:0;;40490:66;;;;-1:-1:-1;;;40490:66:0;;33040:2:1;40490:66:0;;;33022:21:1;33079:2;33059:18;;;33052:30;33118:34;33098:18;;;33091:62;-1:-1:-1;;;33169:18:1;;;33162:35;33214:19;;40490:66:0;32838:401:1;40490:66:0;40665:49;40682:1;40686:7;40695:13;:18;;;40665:8;:49::i;:::-;-1:-1:-1;;;;;40723:18:0;;;;;;:12;:18;;;;;:31;;40753:1;;40723:18;:31;;40753:1;;-1:-1:-1;;;;;40723:31:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;40723:31:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;40761:16:0;;-1:-1:-1;40761:16:0;;;:12;:16;;;;;:29;;-1:-1:-1;;;40761:16:0;;:29;;-1:-1:-1;;40761:29:0;;:::i;:::-;;;-1:-1:-1;;;;;40761:29:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40820:43:0;;;;;;;;-1:-1:-1;;;;;40820:43:0;;;;;-1:-1:-1;;;;;40846:15:0;40820:43;;;;;;;;;-1:-1:-1;40797:20:0;;;:11;:20;;;;;;:66;;;;;;;;;-1:-1:-1;;;40797:66:0;-1:-1:-1;;;;;;40797:66:0;;;;;;;;;;;41113:11;40809:7;-1:-1:-1;41113:11:0;:::i;:::-;41176:1;41135:24;;;:11;:24;;;;;:29;41091:33;;-1:-1:-1;;;;;;41135:29:0;41131:236;;41193:20;41201:11;37967:12;;-1:-1:-1;37957:22:0;37880:105;41193:20;41189:171;;;41253:97;;;;;;;;41280:18;;-1:-1:-1;;;;;41253:97:0;;;;;;41311:28;;;;-1:-1:-1;;;;;41253:97:0;;;;;;;;;-1:-1:-1;41226:24:0;;;:11;:24;;;;;;;:124;;;;;;;;;-1:-1:-1;;;41226:124:0;-1:-1:-1;;;;;;41226:124:0;;;;;;;;;;;;41189:171;41399:7;41395:2;-1:-1:-1;;;;;41380:27:0;41389:4;-1:-1:-1;;;;;41380:27:0;;;;;;;;;;;41414:42;40023:1439;;;39933:1529;;;:::o;65671:371::-;65777:4;65795:17;65814:24;65842:33;65859:4;65865:9;65842:16;:33::i;:::-;65794:81;;-1:-1:-1;65794:81:0;-1:-1:-1;65916:26:0;65907:5;:35;;;;;;;;:::i;:::-;;:58;;;;;65959:6;-1:-1:-1;;;;;65946:19:0;:9;-1:-1:-1;;;;;65946:19:0;;65907:58;65906:128;;;;65983:51;66010:6;66018:4;66024:9;65983:26;:51::i;:::-;65886:148;65671:371;-1:-1:-1;;;;;;65671:371:0:o;38428:1272::-;38556:12;;-1:-1:-1;;;;;38583:16:0;;38575:62;;;;-1:-1:-1;;;38575:62:0;;33985:2:1;38575:62:0;;;33967:21:1;34024:2;34004:18;;;33997:30;34063:34;34043:18;;;34036:62;-1:-1:-1;;;34114:18:1;;;34107:31;34155:19;;38575:62:0;33783:397:1;38575:62:0;38774:21;38782:12;37967;;-1:-1:-1;37957:22:0;37880:105;38774:21;38773:22;38765:64;;;;-1:-1:-1;;;38765:64:0;;34387:2:1;38765:64:0;;;34369:21:1;34426:2;34406:18;;;34399:30;34465:31;34445:18;;;34438:59;34514:18;;38765:64:0;34185:353:1;38765:64:0;38856:12;38844:8;:24;;38836:71;;;;-1:-1:-1;;;38836:71:0;;34745:2:1;38836:71:0;;;34727:21:1;34784:2;34764:18;;;34757:30;34823:34;34803:18;;;34796:62;-1:-1:-1;;;34874:18:1;;;34867:32;34916:19;;38836:71:0;34543:398:1;38836:71:0;-1:-1:-1;;;;;39019:16:0;;38986:30;39019:16;;;:12;:16;;;;;;;;;38986:49;;;;;;;;;-1:-1:-1;;;;;38986:49:0;;;;;-1:-1:-1;;;38986:49:0;;;;;;;;;;;39061:119;;;;;;;;39081:19;;38986:49;;39061:119;;;39081:39;;39111:8;;39081:39;:::i;:::-;-1:-1:-1;;;;;39061:119:0;;;;;39164:8;39129:11;:24;;;:44;;;;:::i;:::-;-1:-1:-1;;;;;39061:119:0;;;;;;-1:-1:-1;;;;;39042:16:0;;;;;;;:12;:16;;;;;;;;:138;;;;;;;;-1:-1:-1;;;39042:138:0;;;;;;;;;;;;39215:43;;;;;;;;;;-1:-1:-1;;;;;39241:15:0;39215:43;;;;;;;;39187:25;;;:11;:25;;;;;;:71;;;;;;;;;-1:-1:-1;;;39187:71:0;-1:-1:-1;;;;;;39187:71:0;;;;;;;;;;;;;;;;;;39199:12;;39311:281;39335:8;39331:1;:12;39311:281;;;39364:38;;39389:12;;-1:-1:-1;;;;;39364:38:0;;;39381:1;;39364:38;;39381:1;;39364:38;39429:59;39460:1;39464:2;39468:12;39482:5;39429:22;:59::i;:::-;39411:150;;;;-1:-1:-1;;;39411:150:0;;;;;;;:::i;:::-;39570:14;;;;:::i;:::-;;;;39345:3;;;;;:::i;:::-;;;;39311:281;;;-1:-1:-1;39600:12:0;:27;;;39634:60;74920:159;43283:690;43420:4;-1:-1:-1;;;;;43437:13:0;;6763:20;6811:8;43433:535;;43476:72;;-1:-1:-1;;;43476:72:0;;-1:-1:-1;;;;;43476:36:0;;;;;:72;;722:10;;43527:4;;43533:7;;43542:5;;43476:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43476:72:0;;;;;;;;-1:-1:-1;;43476:72:0;;;;;;;;;;;;:::i;:::-;;;43463:464;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43707:6;:13;43724:1;43707:18;43703:215;;43740:61;;-1:-1:-1;;;43740:61:0;;;;;;;:::i;43703:215::-;43886:6;43880:13;43871:6;43867:2;43863:15;43856:38;43463:464;-1:-1:-1;;;;;;43598:55:0;-1:-1:-1;;;43598:55:0;;-1:-1:-1;43591:62:0;;43433:535;-1:-1:-1;43956:4:0;43949:11;;56984:747;57065:7;57074:12;57103:9;:16;57123:2;57103:22;57099:625;;57447:4;57432:20;;57426:27;57497:4;57482:20;;57476:27;57555:4;57540:20;;57534:27;57142:9;57526:36;57598:25;57609:4;57526:36;57426:27;57476;57598:10;:25::i;:::-;57591:32;;;;;;;;;57099:625;-1:-1:-1;57672:1:0;;-1:-1:-1;57676:35:0;57099:625;56984:747;;;;;:::o;66457:484::-;66604:4;66622:12;66636:19;66659:6;-1:-1:-1;;;;;66659:17:0;66714:34;;;66750:4;66756:9;66691:75;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;66691:75:0;;;;;;;;;;;;;;-1:-1:-1;;;;;66691:75:0;-1:-1:-1;;;;;;66691:75:0;;;;;;;;;;66659:118;;;;66691:75;66659:118;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66621:156;;;;66796:7;:43;;;;;66837:2;66820:6;:13;:19;;66796:43;:136;;;;-1:-1:-1;66856:29:0;;-1:-1:-1;;;66897:34:0;66856:29;;;;;;;;;;;;:::i;:::-;:76;;66457:484;-1:-1:-1;;;;;;66457:484:0:o;59917:1477::-;60005:7;;60939:66;60926:79;;60922:163;;;-1:-1:-1;61038:1:0;;-1:-1:-1;61042:30:0;61022:51;;60922:163;61199:24;;;61182:14;61199:24;;;;;;;;;36696:25:1;;;36769:4;36757:17;;36737:18;;;36730:45;;;;36791:18;;;36784:34;;;36834:18;;;36827:34;;;61199:24:0;;36668:19:1;;61199:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;61199:24:0;;-1:-1:-1;;61199:24:0;;;-1:-1:-1;;;;;;;61238:20:0;;61234:103;;61291:1;61295:29;61275:50;;;;;;;61234:103;61357:6;-1:-1:-1;61365:20:0;;-1:-1:-1;59917:1477:0;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;565:131::-;-1:-1:-1;;;;;;639:32:1;;629:43;;619:71;;686:1;683;676:12;701:245;759:6;812:2;800:9;791:7;787:23;783:32;780:52;;;828:1;825;818:12;780:52;867:9;854:23;886:30;910:5;886:30;:::i;1143:250::-;1228:1;1238:113;1252:6;1249:1;1246:13;1238:113;;;1328:11;;;1322:18;1309:11;;;1302:39;1274:2;1267:10;1238:113;;;-1:-1:-1;;1385:1:1;1367:16;;1360:27;1143:250::o;1398:271::-;1440:3;1478:5;1472:12;1505:6;1500:3;1493:19;1521:76;1590:6;1583:4;1578:3;1574:14;1567:4;1560:5;1556:16;1521:76;:::i;:::-;1651:2;1630:15;-1:-1:-1;;1626:29:1;1617:39;;;;1658:4;1613:50;;1398:271;-1:-1:-1;;1398:271:1:o;1674:220::-;1823:2;1812:9;1805:21;1786:4;1843:45;1884:2;1873:9;1869:18;1861:6;1843:45;:::i;1899:180::-;1958:6;2011:2;1999:9;1990:7;1986:23;1982:32;1979:52;;;2027:1;2024;2017:12;1979:52;-1:-1:-1;2050:23:1;;1899:180;-1:-1:-1;1899:180:1:o;2292:254::-;2360:6;2368;2421:2;2409:9;2400:7;2396:23;2392:32;2389:52;;;2437:1;2434;2427:12;2389:52;2460:29;2479:9;2460:29;:::i;:::-;2450:39;2536:2;2521:18;;;;2508:32;;-1:-1:-1;;;2292:254:1:o;2551:118::-;2637:5;2630:13;2623:21;2616:5;2613:32;2603:60;;2659:1;2656;2649:12;2674:315;2739:6;2747;2800:2;2788:9;2779:7;2775:23;2771:32;2768:52;;;2816:1;2813;2806:12;2768:52;2839:29;2858:9;2839:29;:::i;:::-;2829:39;;2918:2;2907:9;2903:18;2890:32;2931:28;2953:5;2931:28;:::i;:::-;2978:5;2968:15;;;2674:315;;;;;:::o;2994:328::-;3071:6;3079;3087;3140:2;3128:9;3119:7;3115:23;3111:32;3108:52;;;3156:1;3153;3146:12;3108:52;3179:29;3198:9;3179:29;:::i;:::-;3169:39;;3227:38;3261:2;3250:9;3246:18;3227:38;:::i;:::-;3217:48;;3312:2;3301:9;3297:18;3284:32;3274:42;;2994:328;;;;;:::o;3327:347::-;3378:8;3388:6;3442:3;3435:4;3427:6;3423:17;3419:27;3409:55;;3460:1;3457;3450:12;3409:55;-1:-1:-1;3483:20:1;;-1:-1:-1;;;;;3515:30:1;;3512:50;;;3558:1;3555;3548:12;3512:50;3595:4;3587:6;3583:17;3571:29;;3647:3;3640:4;3631:6;3623;3619:19;3615:30;3612:39;3609:59;;;3664:1;3661;3654:12;3679:614;3776:6;3784;3792;3800;3808;3861:3;3849:9;3840:7;3836:23;3832:33;3829:53;;;3878:1;3875;3868:12;3829:53;3914:9;3901:23;3891:33;;3971:2;3960:9;3956:18;3943:32;3933:42;;4022:2;4011:9;4007:18;3994:32;3984:42;;4077:2;4066:9;4062:18;4049:32;-1:-1:-1;;;;;4096:6:1;4093:30;4090:50;;;4136:1;4133;4126:12;4090:50;4175:58;4225:7;4216:6;4205:9;4201:22;4175:58;:::i;:::-;3679:614;;;;-1:-1:-1;3679:614:1;;-1:-1:-1;4252:8:1;;4149:84;3679:614;-1:-1:-1;;;3679:614:1:o;4298:254::-;4366:6;4374;4427:2;4415:9;4406:7;4402:23;4398:32;4395:52;;;4443:1;4440;4433:12;4395:52;4479:9;4466:23;4456:33;;4508:38;4542:2;4531:9;4527:18;4508:38;:::i;:::-;4498:48;;4298:254;;;;;:::o;4557:410::-;4628:6;4636;4689:2;4677:9;4668:7;4664:23;4660:32;4657:52;;;4705:1;4702;4695:12;4657:52;4745:9;4732:23;-1:-1:-1;;;;;4770:6:1;4767:30;4764:50;;;4810:1;4807;4800:12;4764:50;4849:58;4899:7;4890:6;4879:9;4875:22;4849:58;:::i;:::-;4926:8;;4823:84;;-1:-1:-1;4557:410:1;-1:-1:-1;;;;4557:410:1:o;5212:976::-;5327:6;5335;5343;5351;5359;5412:2;5400:9;5391:7;5387:23;5383:32;5380:52;;;5428:1;5425;5418:12;5380:52;5468:9;5455:23;-1:-1:-1;;;;;5538:2:1;5530:6;5527:14;5524:34;;;5554:1;5551;5544:12;5524:34;5592:6;5581:9;5577:22;5567:32;;5637:7;5630:4;5626:2;5622:13;5618:27;5608:55;;5659:1;5656;5649:12;5608:55;5699:2;5686:16;5725:2;5717:6;5714:14;5711:34;;;5741:1;5738;5731:12;5711:34;5796:7;5789:4;5779:6;5776:1;5772:14;5768:2;5764:23;5760:34;5757:47;5754:67;;;5817:1;5814;5807:12;5754:67;5848:4;5840:13;;;;-1:-1:-1;5872:6:1;-1:-1:-1;5910:20:1;;;5897:34;;-1:-1:-1;5984:2:1;5969:18;;5956:32;;6000:16;;;5997:36;;;6029:1;6026;6019:12;5997:36;;6068:60;6120:7;6109:8;6098:9;6094:24;6068:60;:::i;6745:127::-;6806:10;6801:3;6797:20;6794:1;6787:31;6837:4;6834:1;6827:15;6861:4;6858:1;6851:15;6877:275;6948:2;6942:9;7013:2;6994:13;;-1:-1:-1;;6990:27:1;6978:40;;-1:-1:-1;;;;;7033:34:1;;7069:22;;;7030:62;7027:88;;;7095:18;;:::i;:::-;7131:2;7124:22;6877:275;;-1:-1:-1;6877:275:1:o;7157:980::-;7252:6;7260;7268;7276;7329:3;7317:9;7308:7;7304:23;7300:33;7297:53;;;7346:1;7343;7336:12;7297:53;7369:29;7388:9;7369:29;:::i;:::-;7359:39;;7417:2;7438:38;7472:2;7461:9;7457:18;7438:38;:::i;:::-;7428:48;;7523:2;7512:9;7508:18;7495:32;7485:42;;7578:2;7567:9;7563:18;7550:32;-1:-1:-1;;;;;7642:2:1;7634:6;7631:14;7628:34;;;7658:1;7655;7648:12;7628:34;7696:6;7685:9;7681:22;7671:32;;7741:7;7734:4;7730:2;7726:13;7722:27;7712:55;;7763:1;7760;7753:12;7712:55;7799:2;7786:16;7821:2;7817;7814:10;7811:36;;;7827:18;;:::i;:::-;7869:53;7912:2;7893:13;;-1:-1:-1;;7889:27:1;7885:36;;7869:53;:::i;:::-;7856:66;;7945:2;7938:5;7931:17;7985:7;7980:2;7975;7971;7967:11;7963:20;7960:33;7957:53;;;8006:1;8003;7996:12;7957:53;8061:2;8056;8052;8048:11;8043:2;8036:5;8032:14;8019:45;8105:1;8100:2;8095;8088:5;8084:14;8080:23;8073:34;;8126:5;8116:15;;;;;7157:980;;;;;;;:::o;8142:1151::-;8253:6;8261;8269;8277;8330:3;8318:9;8309:7;8305:23;8301:33;8298:53;;;8347:1;8344;8337:12;8298:53;8383:9;8370:23;8360:33;;8412:2;8461;8450:9;8446:18;8433:32;8423:42;;8512:2;8501:9;8497:18;8484:32;8474:42;;8567:2;8556:9;8552:18;8539:32;-1:-1:-1;;;;;8631:2:1;8623:6;8620:14;8617:34;;;8647:1;8644;8637:12;8617:34;8685:6;8674:9;8670:22;8660:32;;8730:7;8723:4;8719:2;8715:13;8711:27;8701:55;;8752:1;8749;8742:12;8701:55;8788:2;8775:16;8810:2;8806;8803:10;8800:36;;;8816:18;;:::i;:::-;8862:2;8859:1;8855:10;8845:20;;8885:28;8909:2;8905;8901:11;8885:28;:::i;:::-;8947:15;;;9017:11;;;9013:20;;;8978:12;;;;9045:19;;;9042:39;;;9077:1;9074;9067:12;9042:39;9101:11;;;;9121:142;9137:6;9132:3;9129:15;9121:142;;;9203:17;;9191:30;;9154:12;;;;9241;;;;9121:142;;;8142:1151;;;;-1:-1:-1;8142:1151:1;;-1:-1:-1;;;;;;;8142:1151:1:o;9298:260::-;9366:6;9374;9427:2;9415:9;9406:7;9402:23;9398:32;9395:52;;;9443:1;9440;9433:12;9395:52;9466:29;9485:9;9466:29;:::i;:::-;9456:39;;9514:38;9548:2;9537:9;9533:18;9514:38;:::i;9563:380::-;9642:1;9638:12;;;;9685;;;9706:61;;9760:4;9752:6;9748:17;9738:27;;9706:61;9813:2;9805:6;9802:14;9782:18;9779:38;9776:161;;9859:10;9854:3;9850:20;9847:1;9840:31;9894:4;9891:1;9884:15;9922:4;9919:1;9912:15;9776:161;;9563:380;;;:::o;10362:356::-;10564:2;10546:21;;;10583:18;;;10576:30;10642:34;10637:2;10622:18;;10615:62;10709:2;10694:18;;10362:356::o;11416:127::-;11477:10;11472:3;11468:20;11465:1;11458:31;11508:4;11505:1;11498:15;11532:4;11529:1;11522:15;11548:125;11613:9;;;11634:10;;;11631:36;;;11647:18;;:::i;13224:168::-;13297:9;;;13328;;13345:15;;;13339:22;;13325:37;13315:71;;13366:18;;:::i;13800:135::-;13839:3;13860:17;;;13857:43;;13880:18;;:::i;:::-;-1:-1:-1;13927:1:1;13916:13;;13800:135::o;15237:545::-;15339:2;15334:3;15331:11;15328:448;;;15375:1;15400:5;15396:2;15389:17;15445:4;15441:2;15431:19;15515:2;15503:10;15499:19;15496:1;15492:27;15486:4;15482:38;15551:4;15539:10;15536:20;15533:47;;;-1:-1:-1;15574:4:1;15533:47;15629:2;15624:3;15620:12;15617:1;15613:20;15607:4;15603:31;15593:41;;15684:82;15702:2;15695:5;15692:13;15684:82;;;15747:17;;;15728:1;15717:13;15684:82;;15958:1206;-1:-1:-1;;;;;16077:3:1;16074:27;16071:53;;;16104:18;;:::i;:::-;16133:94;16223:3;16183:38;16215:4;16209:11;16183:38;:::i;:::-;16177:4;16133:94;:::i;:::-;16253:1;16278:2;16273:3;16270:11;16295:1;16290:616;;;;16950:1;16967:3;16964:93;;;-1:-1:-1;17023:19:1;;;17010:33;16964:93;-1:-1:-1;;15915:1:1;15911:11;;;15907:24;15903:29;15893:40;15939:1;15935:11;;;15890:57;17070:78;;16263:895;;16290:616;15184:1;15177:14;;;15221:4;15208:18;;-1:-1:-1;;16326:17:1;;;16427:9;16449:229;16463:7;16460:1;16457:14;16449:229;;;16552:19;;;16539:33;16524:49;;16659:4;16644:20;;;;16612:1;16600:14;;;;16479:12;16449:229;;;16453:3;16706;16697:7;16694:16;16691:159;;;16830:1;16826:6;16820:3;16814;16811:1;16807:11;16803:21;16799:34;16795:39;16782:9;16777:3;16773:19;16760:33;16756:79;16748:6;16741:95;16691:159;;;16893:1;16887:3;16884:1;16880:11;16876:19;16870:4;16863:33;16263:895;;15958:1206;;;:::o;18686:1008::-;18953:2;18935:21;;;18972:18;;18965:34;;;-1:-1:-1;;;;;;19011:31:1;;19008:51;;;19055:1;19052;19045:12;19008:51;19089:6;19086:1;19082:14;19146:6;19138;19133:2;19122:9;19118:18;19105:48;19222:2;19172:22;;;19288:18;;;19284:27;;19244:4;19264:18;;;19257:55;;;;19360:13;;19214:11;;;19382:21;;;19454:15;;;;19487:1;;19427:3;19419:12;;19497:171;19511:8;19508:1;19505:15;19497:171;;;19574:13;;19562:26;;19643:15;;;;19535:1;19528:9;;;;;19608:12;;;;19497:171;;;-1:-1:-1;19685:3:1;18686:1008;-1:-1:-1;;;;;;;;18686:1008:1:o;20115:496::-;20294:3;20332:6;20326:13;20348:66;20407:6;20402:3;20395:4;20387:6;20383:17;20348:66;:::i;:::-;20477:13;;20436:16;;;;20499:70;20477:13;20436:16;20546:4;20534:17;;20499:70;:::i;:::-;20585:20;;20115:496;-1:-1:-1;;;;20115:496:1:o;22521:184::-;22591:6;22644:2;22632:9;22623:7;22619:23;22615:32;22612:52;;;22660:1;22657;22650:12;22612:52;-1:-1:-1;22683:16:1;;22521:184;-1:-1:-1;22521:184:1:o;23438:245::-;23505:6;23558:2;23546:9;23537:7;23533:23;23529:32;23526:52;;;23574:1;23571;23564:12;23526:52;23606:9;23600:16;23625:28;23647:5;23625:28;:::i;25950:128::-;26017:9;;;26038:11;;;26035:37;;;26052:18;;:::i;26843:127::-;26904:10;26899:3;26895:20;26892:1;26885:31;26935:4;26932:1;26925:15;26959:4;26956:1;26949:15;26975:120;27015:1;27041;27031:35;;27046:18;;:::i;:::-;-1:-1:-1;27080:9:1;;26975:120::o;28627:136::-;28666:3;28694:5;28684:39;;28703:18;;:::i;:::-;-1:-1:-1;;;28739:18:1;;28627:136::o;29184:563::-;29449:2;29445:15;;;-1:-1:-1;;;;;;29441:53:1;29429:66;;29411:3;-1:-1:-1;;;;;29507:31:1;;29504:51;;;29551:1;29548;29541:12;29504:51;29585:6;29582:1;29578:14;29636:6;29628;29623:2;29618:3;29614:12;29601:42;29702:2;29662:16;;29694:11;;;29687:27;;;;29738:2;29730:11;;29184:563;-1:-1:-1;;;;29184:563:1:o;29752:127::-;29813:10;29808:3;29804:20;29801:1;29794:31;29844:4;29841:1;29834:15;29868:4;29865:1;29858:15;30239:415;30441:2;30423:21;;;30480:2;30460:18;;;30453:30;30519:34;30514:2;30499:18;;30492:62;-1:-1:-1;;;30585:2:1;30570:18;;30563:49;30644:3;30629:19;;30239:415::o;30659:112::-;30691:1;30717;30707:35;;30722:18;;:::i;:::-;-1:-1:-1;30756:9:1;;30659:112::o;31810:197::-;31848:3;31876:6;31917:2;31910:5;31906:14;31944:2;31935:7;31932:15;31929:41;;31950:18;;:::i;:::-;31999:1;31986:15;;31810:197;-1:-1:-1;;;31810:197:1:o;33244:200::-;-1:-1:-1;;;;;33380:10:1;;;33368;;;33364:27;;33403:12;;;33400:38;;;33418:18;;:::i;:::-;33400:38;33244:200;;;;:::o;33449:197::-;-1:-1:-1;;;;;33571:10:1;;;33583;;;33567:27;;33606:11;;;33603:37;;;33620:18;;:::i;33651:127::-;33712:10;33707:3;33703:20;33700:1;33693:31;33743:4;33740:1;33733:15;33767:4;33764:1;33757:15;34946:489;-1:-1:-1;;;;;35215:15:1;;;35197:34;;35267:15;;35262:2;35247:18;;35240:43;35314:2;35299:18;;35292:34;;;35362:3;35357:2;35342:18;;35335:31;;;35140:4;;35383:46;;35409:19;;35401:6;35383:46;:::i;35440:249::-;35509:6;35562:2;35550:9;35541:7;35537:23;35533:32;35530:52;;;35578:1;35575;35568:12;35530:52;35610:9;35604:16;35629:30;35653:5;35629:30;:::i;35694:289::-;35869:6;35858:9;35851:25;35912:2;35907;35896:9;35892:18;35885:30;35832:4;35932:45;35973:2;35962:9;35958:18;35950:6;35932:45;:::i;35988:287::-;36117:3;36155:6;36149:13;36171:66;36230:6;36225:3;36218:4;36210:6;36206:17;36171:66;:::i;:::-;36253:16;;;;;35988:287;-1:-1:-1;;35988:287:1:o

Swarm Source

ipfs://84e53820ba0dc17757572b4279571f183b8a55983e52a30963a987ada9cd2d0a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services