Token

Spinft Cyberpunk Pi 3d (SCP3D)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

593,274.588407586215569214 SCP3D

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x8396ad5feb207eabb6df9f5c19a3da771db47ce7

Filtered by Token Holder

0x0000000000000000000000000000000000000000

Null: 0x000...000

Balance

0 SCP3D

Value

$0.00

0x0000000000000000000000000000000000000000

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NFTMiner

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-16
*/

/**
 *Submitted for verification at Etherscan.io on 2023-04-15
*/

// Sources flattened with hardhat v2.13.0 https://hardhat.org

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

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

pragma solidity ^0.8.0;

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

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


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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


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


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


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


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

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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


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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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


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


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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


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


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @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) {
        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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. 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 mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. 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 mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}


// File contracts/interfaces/IMasterChefBSC.sol


pragma solidity ^0.8.0;

interface IMasterChefBSC {
    function pendingCake(uint256 pid, address user) external view returns (uint256);

    function deposit(uint256 pid, uint256 amount) external;

    function withdraw(uint256 pid, uint256 amount) external;

    function emergencyWithdraw(uint256 pid) external;
}


// File contracts/interfaces/IMintNft.sol


pragma solidity ^0.8.0;

interface IMintNft {
    function mint(address to) external;
}


// File contracts/NFTMiner.sol



pragma solidity ^0.8.0;








contract NFTMiner is Ownable, ERC20 {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    using EnumerableSet for EnumerableSet.AddressSet;
    EnumerableSet.AddressSet private _multLP;

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt.
        uint256 multLpRewardDebt; //multLp Reward debt.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. coins to distribute per block.
        uint256 lastRewardBlock;  // Last block number that coins distribution occurs.
        uint256 accPerShare; // Accumulated coins per share, times 1e12.
        uint256 accMultLpPerShare; //Accumulated multLp per share
        uint256 totalAmount;    // Total amount of current pool deposit.
    }

    // coin tokens created per block.
    uint256 public perBlock = 800000000000000000;
//    uint256 public perBlock = 100*10**18;
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Corresponding to the pid of the multLP pool
    mapping(uint256 => uint256) public poolCorrespond;
    // pid corresponding address
    mapping(address => uint256) public LpOfPid;
    // Control mining
    bool public paused = false;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when coin mining starts.
    uint256 public startBlock;
    uint256 public endBlock;
    // multLP MasterChef
    address public multLpChef;
    // multLP Token
    address public multLpToken;
    // How many blocks are halved
    uint256 public halvingPeriod = 999999999;
    uint256 public perNFTBurn = 100 * 10 ** 18;
    address public nft;
    uint256 public totalQuota;
    uint256 public soldQuota;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(string memory name_, string memory symbol_,
        uint256 _startBlock, uint256 _endBlock, address _nft, uint256 _quota
    ) ERC20(name_, symbol_){
        startBlock = _startBlock;
        endBlock = _endBlock;
        nft = _nft;
        totalQuota = _quota;
    }
    function setNFT(address _nft) public onlyOwner {
        require(_nft != address(0), 'Address is zero address');
        nft = _nft;
    }
    modifier isOpening() {
        uint256 b = block.number;
        require(startBlock <= b && b <= endBlock, "Not in opening period");
        _;
    }
    // Set the number of coin produced by each block
    function setPerBlock(uint256 newPerBlock) public onlyOwner {
        massUpdatePools();
        perBlock = newPerBlock;
    }
    function poolLength() public view returns (uint256) {
        return poolInfo.length;
    }

    function addMultLP(address _addLP) public onlyOwner returns (bool) {
        require(_addLP != address(0), "LP is the zero address");
        IERC20(_addLP).approve(multLpChef, type(uint256).max);
        return EnumerableSet.add(_multLP, _addLP);
    }

    function isMultLP(address _LP) public view returns (bool) {
        return EnumerableSet.contains(_multLP, _LP);
    }

    function getMultLPLength() public view returns (uint256) {
        return EnumerableSet.length(_multLP);
    }

    function getMultLPAddress(uint256 _pid) public view returns (address){
        require(_pid <= getMultLPLength() - 1, "not find this multLP");
        return EnumerableSet.at(_multLP, _pid);
    }

    function setPause() public onlyOwner {
        paused = !paused;
    }

    function setMultLP(address _multLpToken, address _multLpChef) public onlyOwner {
        require(_multLpToken != address(0) && _multLpChef != address(0), "is the zero address");
        multLpToken = _multLpToken;
        multLpChef = _multLpChef;
    }

    function replaceMultLP(address _multLpToken, address _multLpChef) public onlyOwner {
        require(_multLpToken != address(0) && _multLpChef != address(0), "is the zero address");
        require(paused == true, "No mining suspension");
        multLpToken = _multLpToken;
        multLpChef = _multLpChef;
        uint256 length = getMultLPLength();
        while (length > 0) {
            address dAddress = EnumerableSet.at(_multLP, 0);
            uint256 pid = LpOfPid[dAddress];
            IMasterChefBSC(multLpChef).emergencyWithdraw(poolCorrespond[pid]);
            EnumerableSet.remove(_multLP, dAddress);
            length--;
        }
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner {
        require(address(_lpToken) != address(0), "_lpToken is the zero address");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
        lpToken : _lpToken,
        allocPoint : _allocPoint,
        lastRewardBlock : lastRewardBlock,
        accPerShare : 0,
        accMultLpPerShare : 0,
        totalAmount : 0
        }));
        LpOfPid[address(_lpToken)] = poolLength() - 1;
    }

    // Update the given pool's coin allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // The current pool corresponds to the pid of the multLP pool
    function setPoolCorr(uint256 _pid, uint256 _sid) public onlyOwner {
        require(_pid <= poolLength() - 1, "not find this pool");
        poolCorrespond[_pid] = _sid;
    }

    function phase(uint256 blockNumber) public view returns (uint256) {
        if (halvingPeriod == 0) {
            return 0;
        }
        if (blockNumber > startBlock) {
            return (blockNumber.sub(startBlock).sub(1)).div(halvingPeriod);
        }
        return 0;
    }

    function reward(uint256 blockNumber) public view returns (uint256) {
        uint256 _phase = phase(blockNumber);
        return perBlock.div(2 ** _phase).mul(poolLength());
    }

    function getBlockReward(uint256 _lastRewardBlock) public view returns (uint256) {
        uint256 blockReward = 0;
        uint256 n = phase(_lastRewardBlock);
        uint256 m = phase(block.number);
        while (n < m) {
            n++;
            uint256 r = n.mul(halvingPeriod).add(startBlock);
            blockReward = blockReward.add((r.sub(_lastRewardBlock)).mul(reward(r)));
            _lastRewardBlock = r;
        }
        blockReward = blockReward.add((block.number.sub(_lastRewardBlock)).mul(reward(block.number)));
        return blockReward;
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply;
        if (isMultLP(address(pool.lpToken))) {
            if (pool.totalAmount == 0) {
                pool.lastRewardBlock = block.number;
                return;
            }
            lpSupply = pool.totalAmount;
        } else {
            lpSupply = pool.lpToken.balanceOf(address(this));
            if (lpSupply == 0) {
                pool.lastRewardBlock = block.number;
                return;
            }
        }
        uint256 blockReward = getBlockReward(pool.lastRewardBlock);
        if (blockReward <= 0) {
            return;
        }
        uint256 coinReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);

        pool.accPerShare = pool.accPerShare.add(coinReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // View function to see pending coins on frontend.
    function pending(uint256 _pid, address _user) external view returns (uint256, uint256){
        PoolInfo storage pool = poolInfo[_pid];
        if (isMultLP(address(pool.lpToken))) {
            (uint256 amount, uint256 tokenAmount) = pendingCoinAndToken(_pid, _user);
            return (amount, tokenAmount);
        } else {
            uint256 amount = pendingCoin(_pid, _user);
            return (amount, 0);
        }
    }

    function pendingCoinAndToken(uint256 _pid, address _user) private view returns (uint256, uint256){
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accPerShare = pool.accPerShare;
        uint256 accMultLpPerShare = pool.accMultLpPerShare;
        if (user.amount > 0) {
            uint256 TokenPending = IMasterChefBSC(multLpChef).pendingCake(poolCorrespond[_pid], address(this));
            accMultLpPerShare = accMultLpPerShare.add(TokenPending.mul(1e12).div(pool.totalAmount));
            uint256 userPending = user.amount.mul(accMultLpPerShare).div(1e12).sub(user.multLpRewardDebt);
            if (block.number > pool.lastRewardBlock) {
                uint256 blockReward = getBlockReward(pool.lastRewardBlock);
                uint256 coinReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
                accPerShare = accPerShare.add(coinReward.mul(1e12).div(pool.totalAmount));
                return (user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt), userPending);
            }
            if (block.number == pool.lastRewardBlock) {
                return (user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt), userPending);
            }
        }
        return (0, 0);
    }

    function pendingCoin(uint256 _pid, address _user) private view returns (uint256){
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accPerShare = pool.accPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (user.amount > 0) {
            if (block.number > pool.lastRewardBlock) {
                uint256 blockReward = getBlockReward(pool.lastRewardBlock);
                uint256 coinReward = blockReward.mul(pool.allocPoint).div(totalAllocPoint);
                accPerShare = accPerShare.add(coinReward.mul(1e12).div(lpSupply));
                return user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt);
            }
            if (block.number == pool.lastRewardBlock) {
                return user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt);
            }
        }
        return 0;
    }

    // Deposit LP tokens to BSCPool for coin allocation.
    function deposit(uint256 _pid, uint256 _amount) public notPause isOpening {
        PoolInfo storage pool = poolInfo[_pid];
        if (isMultLP(address(pool.lpToken))) {
            depositCoinAndToken(_pid, _amount, msg.sender);
        } else {
            depositCoin(_pid, _amount, msg.sender);
        }
    }

    function depositCoinAndToken(uint256 _pid, uint256 _amount, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pendingAmount = user.amount.mul(pool.accPerShare).div(1e12).sub(user.rewardDebt);
            if (pendingAmount > 0) {
                safeCoinTransfer(_user, pendingAmount);
            }
            uint256 beforeToken = IERC20(multLpToken).balanceOf(address(this));
            IMasterChefBSC(multLpChef).deposit(poolCorrespond[_pid], 0);
            uint256 afterToken = IERC20(multLpToken).balanceOf(address(this));
            pool.accMultLpPerShare = pool.accMultLpPerShare.add(afterToken.sub(beforeToken).mul(1e12).div(pool.totalAmount));
            uint256 tokenPending = user.amount.mul(pool.accMultLpPerShare).div(1e12).sub(user.multLpRewardDebt);
            if (tokenPending > 0) {
                IERC20(multLpToken).safeTransfer(_user, tokenPending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(_user, address(this), _amount);
            if (pool.totalAmount == 0) {
                IMasterChefBSC(multLpChef).deposit(poolCorrespond[_pid], _amount);
                user.amount = user.amount.add(_amount);
                pool.totalAmount = pool.totalAmount.add(_amount);
            } else {
                uint256 beforeToken = IERC20(multLpToken).balanceOf(address(this));
                IMasterChefBSC(multLpChef).deposit(poolCorrespond[_pid], _amount);
                uint256 afterToken = IERC20(multLpToken).balanceOf(address(this));
                pool.accMultLpPerShare = pool.accMultLpPerShare.add(afterToken.sub(beforeToken).mul(1e12).div(pool.totalAmount));
                user.amount = user.amount.add(_amount);
                pool.totalAmount = pool.totalAmount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        user.multLpRewardDebt = user.amount.mul(pool.accMultLpPerShare).div(1e12);
        emit Deposit(_user, _pid, _amount);
    }

    function depositCoin(uint256 _pid, uint256 _amount, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pendingAmount = user.amount.mul(pool.accPerShare).div(1e12).sub(user.rewardDebt);
            if (pendingAmount > 0) {
                safeCoinTransfer(_user, pendingAmount);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(_user, address(this), _amount);
            user.amount = user.amount.add(_amount);
            pool.totalAmount = pool.totalAmount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        emit Deposit(_user, _pid, _amount);
    }

    // Withdraw LP tokens from BSCPool.
    function withdraw(uint256 _pid, uint256 _amount) public notPause {
        PoolInfo storage pool = poolInfo[_pid];
        if (isMultLP(address(pool.lpToken))) {
            withdrawCoinAndToken(_pid, _amount, msg.sender);
        } else {
            withdrawCoin(_pid, _amount, msg.sender);
        }
    }

    function withdrawCoinAndToken(uint256 _pid, uint256 _amount, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        require(user.amount >= _amount, "withdrawCoinAndToken: not good");
        updatePool(_pid);
        uint256 pendingAmount = user.amount.mul(pool.accPerShare).div(1e12).sub(user.rewardDebt);
        if (pendingAmount > 0) {
            safeCoinTransfer(_user, pendingAmount);
        }
        if (_amount > 0) {
            uint256 beforeToken = IERC20(multLpToken).balanceOf(address(this));
            IMasterChefBSC(multLpChef).withdraw(poolCorrespond[_pid], _amount);
            uint256 afterToken = IERC20(multLpToken).balanceOf(address(this));
            pool.accMultLpPerShare = pool.accMultLpPerShare.add(afterToken.sub(beforeToken).mul(1e12).div(pool.totalAmount));
            uint256 tokenPending = user.amount.mul(pool.accMultLpPerShare).div(1e12).sub(user.multLpRewardDebt);
            if (tokenPending > 0) {
                IERC20(multLpToken).safeTransfer(_user, tokenPending);
            }
            user.amount = user.amount.sub(_amount);
            pool.totalAmount = pool.totalAmount.sub(_amount);
            pool.lpToken.safeTransfer(_user, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        user.multLpRewardDebt = user.amount.mul(pool.accMultLpPerShare).div(1e12);
        emit Withdraw(_user, _pid, _amount);
    }

    function withdrawCoin(uint256 _pid, uint256 _amount, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        require(user.amount >= _amount, "withdrawCoin: not good");
        updatePool(_pid);
        uint256 pendingAmount = user.amount.mul(pool.accPerShare).div(1e12).sub(user.rewardDebt);
        if (pendingAmount > 0) {
            safeCoinTransfer(_user, pendingAmount);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalAmount = pool.totalAmount.sub(_amount);
            pool.lpToken.safeTransfer(_user, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        emit Withdraw(_user, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public notPause {
        PoolInfo storage pool = poolInfo[_pid];
        if (isMultLP(address(pool.lpToken))) {
            emergencyWithdrawCoinAndToken(_pid, msg.sender);
        } else {
            emergencyWithdrawCoin(_pid, msg.sender);
        }
    }

    function emergencyWithdrawCoinAndToken(uint256 _pid, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 amount = user.amount;
        uint256 beforeToken = IERC20(multLpToken).balanceOf(address(this));
        IMasterChefBSC(multLpChef).withdraw(poolCorrespond[_pid], amount);
        uint256 afterToken = IERC20(multLpToken).balanceOf(address(this));
        pool.accMultLpPerShare = pool.accMultLpPerShare.add(afterToken.sub(beforeToken).mul(1e12).div(pool.totalAmount));
        user.amount = 0;
        user.rewardDebt = 0;
        pool.lpToken.safeTransfer(_user, amount);
        pool.totalAmount = pool.totalAmount.sub(amount);
        emit EmergencyWithdraw(_user, _pid, amount);
    }

    function emergencyWithdrawCoin(uint256 _pid, address _user) private {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.lpToken.safeTransfer(_user, amount);
        pool.totalAmount = pool.totalAmount.sub(amount);
        emit EmergencyWithdraw(_user, _pid, amount);
    }

    // Safe coin transfer function, just in case if rounding error causes pool to not have enough coins.
    function safeCoinTransfer(address _to, uint256 _amount) internal {
        super._mint(_to, _amount);
    }

    modifier notPause() {
        require(!paused, "Mining has been suspended");
        _;
    }
    modifier hasQuota() {
        require(soldQuota < totalQuota, "not enough quota");
        _;
    }
    function burnForExchangeNFT(uint256 _pid) external hasQuota {
        withdrawCoin(_pid, 0, msg.sender);
        if (balanceOf(msg.sender) >= perNFTBurn) {
            _burn(msg.sender, perNFTBurn);
            soldQuota = soldQuota.add(1);
            IMintNft(nft).mint(msg.sender);
        }
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_endBlock","type":"uint256"},{"internalType":"address","name":"_nft","type":"address"},{"internalType":"uint256","name":"_quota","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"LpOfPid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addLP","type":"address"}],"name":"addMultLP","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"burnForExchangeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lastRewardBlock","type":"uint256"}],"name":"getBlockReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"getMultLPAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMultLPLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"halvingPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_LP","type":"address"}],"name":"isMultLP","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"multLpChef","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multLpToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pending","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"perBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"perNFTBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"phase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolCorrespond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accPerShare","type":"uint256"},{"internalType":"uint256","name":"accMultLpPerShare","type":"uint256"},{"internalType":"uint256","name":"totalAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_multLpToken","type":"address"},{"internalType":"address","name":"_multLpChef","type":"address"}],"name":"replaceMultLP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"reward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_multLpToken","type":"address"},{"internalType":"address","name":"_multLpChef","type":"address"}],"name":"setMultLP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nft","type":"address"}],"name":"setNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPerBlock","type":"uint256"}],"name":"setPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_sid","type":"uint256"}],"name":"setPoolCorr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"soldQuota","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalQuota","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"multLpRewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","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)

00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000001118b8c00000000000000000000000000000000000000000000000000000000011b6ecc0000000000000000000000007c073cc4faa174bde4a631140678b1990ab795010000000000000000000000000000000000000000000000000b1a2bc2ec50000000000000000000000000000000000000000000000000000000000000000000165370696e667420437962657270756e6b2050692033640000000000000000000000000000000000000000000000000000000000000000000000000000000000055343503344000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Spinft Cyberpunk Pi 3d
Arg [1] : symbol_ (string): SCP3D
Arg [2] : _startBlock (uint256): 17927052
Arg [3] : _endBlock (uint256): 18575052
Arg [4] : _nft (address): 0x7C073CC4Faa174bDE4a631140678b1990ab79501
Arg [5] : _quota (uint256): 800000000000000000

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [2] : 0000000000000000000000000000000000000000000000000000000001118b8c
Arg [3] : 00000000000000000000000000000000000000000000000000000000011b6ecc
Arg [4] : 0000000000000000000000007c073cc4faa174bde4a631140678b1990ab79501
Arg [5] : 0000000000000000000000000000000000000000000000000b1a2bc2ec500000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000016
Arg [7] : 5370696e667420437962657270756e6b20506920336400000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [9] : 5343503344000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

61047:20223:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9550:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64219:93;64289:8;:15;64219:93;;;816:25:1;;;804:2;789:18;64219:93:0;670:177:1;62819:23:0;;;;;;11901:201;;;;;;:::i;:::-;;:::i;:::-;;;1473:14:1;;1466:22;1448:41;;1436:2;1421:18;11901:201:0;1308:187:1;67579:291:0;;;;;;:::i;:::-;;:::i;62208:26::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2004:32:1;;;1986:51;;2068:2;2053:18;;2046:34;;;;2096:18;;;2089:34;;;;2154:2;2139:18;;2132:34;2197:3;2182:19;;2175:35;2024:3;2226:19;;2219:35;1973:3;1958:19;62208:26:0;1685:575:1;62696:34:0;;;;;;10670:108;10758:12;;10670:108;;63043:42;;;;;;66224:694;;;;;;:::i;:::-;;:::i;:::-;;12682:295;;;;;;:::i;:::-;;:::i;10512:93::-;;;10595:2;3460:36:1;;3448:2;3433:18;10512:93:0;3318:184:1;13386:238:0;;;;;;:::i;:::-;;:::i;63149:24::-;;;;;;64833:199;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3671:32:1;;;3653:51;;3641:2;3626:18;64833:199:0;3507:203:1;76229:315:0;;;;;;:::i;:::-;;:::i;63092:18::-;;;;;-1:-1:-1;;;;;63092:18:0;;;62787:25;;;;;;68988:1009;;;;;;:::i;:::-;;:::i;78958:307::-;;;;;;:::i;:::-;;:::i;64320:257::-;;;;;;:::i;:::-;;:::i;62996:40::-;;;;;;62575:26;;;;;;;;;68732:180;;;:::i;67014:304::-;;;;;;:::i;:::-;;:::i;62928:26::-;;;;;-1:-1:-1;;;;;62928:26:0;;;10841:127;;;;;;:::i;:::-;-1:-1:-1;;;;;10942:18:0;10915:7;10942:18;;;:9;:18;;;;;;;10841:127;2955:103;;;:::i;64585:120::-;;;;;;:::i;:::-;;:::i;64085:128::-;;;;;;:::i;:::-;;:::i;63117:25::-;;;;;;2307:87;2353:7;2380:6;-1:-1:-1;;;;;2380:6:0;2307:87;;62290:64;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5124:25:1;;;5180:2;5165:18;;5158:34;;;;5208:18;;;5201:34;5112:2;5097:18;62290:64:0;4922:319:1;68068:581:0;;;;;;:::i;:::-;;:::i;9769:104::-;;;:::i;14127:436::-;;;;;;:::i;:::-;;:::i;11174:193::-;;;;;;:::i;:::-;;:::i;67878:182::-;;;;;;:::i;:::-;;:::i;65385:670::-;;;;;;:::i;:::-;;:::i;62503:42::-;;;;;;:::i;:::-;;;;;;;;;;;;;;67393:178;;;;;;:::i;:::-;;:::i;62413:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;65040:72;;;:::i;62085:44::-;;;;;;11430:151;;;;;;:::i;:::-;;:::i;62875:25::-;;;;;-1:-1:-1;;;;;62875:25:0;;;72835:322;;;;;;:::i;:::-;;:::i;70061:439::-;;;;;;:::i;:::-;;:::i;:::-;;;;5813:25:1;;;5869:2;5854:18;;5847:34;;;;5786:18;70061:439:0;5639:248:1;64713:112:0;;;:::i;65120:257::-;;;;;;:::i;:::-;;:::i;3213:201::-;;;;;;:::i;:::-;;:::i;63725:141::-;;;;;;:::i;:::-;;:::i;80960:307::-;;;;;;:::i;:::-;;:::i;9550:100::-;9604:13;9637:5;9630:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9550:100;:::o;11901:201::-;11984:4;932:10;12040:32;932:10;12056:7;12065:6;12040:8;:32::i;:::-;12090:4;12083:11;;;11901:201;;;;;:::o;67579:291::-;67636:7;67660:13;;67677:1;67660:18;67656:59;;-1:-1:-1;67702:1:0;;67579:291;-1:-1:-1;67579:291:0:o;67656:59::-;67743:10;;67729:11;:24;67725:119;;;67777:55;67818:13;;67778:34;67810:1;67778:27;67794:10;;67778:11;:15;;:27;;;;:::i;:::-;:31;;:34::i;:::-;67777:40;;:55::i;67725:119::-;-1:-1:-1;67861:1:0;;67579:291;-1:-1:-1;67579:291:0:o;62208:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62208:26:0;;;;-1:-1:-1;62208:26:0;;;;;:::o;66224:694::-;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;66329:31:0;::::1;66321:72;;;::::0;-1:-1:-1;;;66321:72:0;;6479:2:1;66321:72:0::1;::::0;::::1;6461:21:1::0;6518:2;6498:18;;;6491:30;6557;6537:18;;;6530:58;6605:18;;66321:72:0::1;;;;;;;;;66408:11;66404:61;;;66436:17;:15;:17::i;:::-;66475:23;66516:10;;66501:12;:25;:53;;66544:10;;66501:53;;;66529:12;66501:53;66583:15;::::0;66475:79;;-1:-1:-1;66583:32:0::1;::::0;66603:11;66583:19:::1;:32::i;:::-;66565:15;:50:::0;66640:213:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;66640:213:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;66640:213:0;;;;;;;;;;;;;;;;;;66626:8:::1;:228:::0;;::::1;::::0;;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;66626:228:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64289:15;66894:16:::1;;;;:::i;:::-;-1:-1:-1::0;;;;;66865:26:0;;::::1;;::::0;;;:7:::1;:26;::::0;;;;:45;;;;-1:-1:-1;;;66224:694:0:o;12682:295::-;12813:4;932:10;12871:38;12887:4;932:10;12902:6;12871:15;:38::i;:::-;12920:27;12930:4;12936:2;12940:6;12920:9;:27::i;:::-;-1:-1:-1;12965:4:0;;12682:295;-1:-1:-1;;;;12682:295:0:o;13386:238::-;13474:4;932:10;13530:64;932:10;13546:7;13583:10;13555:25;932:10;13546:7;13555:9;:25::i;:::-;:38;;;;:::i;:::-;13530:8;:64::i;64833:199::-;64894:7;64949:1;64929:17;:15;:17::i;:::-;:21;;;;:::i;:::-;64921:4;:29;;64913:62;;;;-1:-1:-1;;;64913:62:0;;7231:2:1;64913:62:0;;;7213:21:1;7270:2;7250:18;;;7243:30;-1:-1:-1;;;7289:18:1;;;7282:50;7349:18;;64913:62:0;7029:344:1;64913:62:0;64993:31;65010:7;65019:4;64993:16;:31::i;76229:315::-;80790:6;;;;80789:7;80781:45;;;;-1:-1:-1;;;80781:45:0;;;;;;;:::i;:::-;76305:21:::1;76329:8;76338:4;76329:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;76375:12:::0;;76329:14;;-1:-1:-1;76358:31:0::1;::::0;-1:-1:-1;;;;;76375:12:0::1;76358:8;:31::i;:::-;76354:183;;;76406:47;76427:4;76433:7;76442:10;76406:20;:47::i;:::-;76294:250;76229:315:::0;;:::o;76354:183::-:1;76486:39;76499:4;76505:7;76514:10;76486:12;:39::i;68988:1009::-:0;69040:21;69064:8;69073:4;69064:14;;;;;;;;:::i;:::-;;;;;;;;;;;69040:38;;69109:4;:20;;;69093:12;:36;69089:75;;69146:7;68988:1009;:::o;69089:75::-;69222:12;;69174:16;;69205:31;;-1:-1:-1;;;;;69222:12:0;69205:8;:31::i;:::-;69201:436;;;69257:4;:16;;;69277:1;69257:21;69253:122;;-1:-1:-1;69322:12:0;69299:20;;;;:35;-1:-1:-1;68988:1009:0:o;69253:122::-;-1:-1:-1;69400:16:0;;;;69201:436;;;69460:12;;:37;;-1:-1:-1;;;69460:37:0;;69491:4;69460:37;;;3653:51:1;-1:-1:-1;;;;;69460:12:0;;;;:22;;3626:18:1;;69460:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69449:48;;69516:8;69528:1;69516:13;69512:114;;-1:-1:-1;69573:12:0;69550:20;;;;:35;-1:-1:-1;68988:1009:0:o;69512:114::-;69647:19;69669:36;69684:4;:20;;;69669:14;:36::i;:::-;69647:58;;69735:1;69720:11;:16;69716:55;;69753:7;;;68988:1009;:::o;69716:55::-;69781:18;69802:53;69839:15;;69802:32;69818:4;:15;;;69802:11;:15;;:32;;;;:::i;:53::-;69781:74;-1:-1:-1;69887:56:0;69908:34;69933:8;69908:20;69781:74;69923:4;69908:14;:20::i;:34::-;69887:16;;;;;:20;:56::i;:::-;69868:16;;;:75;-1:-1:-1;;69977:12:0;69954:20;;;;:35;;;;-1:-1:-1;;68988:1009:0:o;78958:307::-;80790:6;;;;80789:7;80781:45;;;;-1:-1:-1;;;80781:45:0;;;;;;;:::i;:::-;79026:21:::1;79050:8;79059:4;79050:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;79096:12:::0;;79050:14;;-1:-1:-1;79079:31:0::1;::::0;-1:-1:-1;;;;;79096:12:0::1;79079:8;:31::i;:::-;79075:183;;;79127:47;79157:4;79163:10;79127:29;:47::i;:::-;79015:250;78958:307:::0;:::o;79075:183::-:1;79207:39;79229:4;79235:10;79207:21;:39::i;64320:257::-:0;64381:4;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;64406:20:0;::::1;64398:55;;;::::0;-1:-1:-1;;;64398:55:0;;8255:2:1;64398:55:0::1;::::0;::::1;8237:21:1::0;8294:2;8274:18;;;8267:30;-1:-1:-1;;;8313:18:1;;;8306:52;8375:18;;64398:55:0::1;8053:346:1::0;64398:55:0::1;64487:10;::::0;64464:53:::1;::::0;-1:-1:-1;;;64464:53:0;;-1:-1:-1;;;;;64487:10:0;;::::1;64464:53;::::0;::::1;8578:51:1::0;-1:-1:-1;;8645:18:1;;;8638:34;64464:22:0;;::::1;::::0;::::1;::::0;8551:18:1;;64464:53:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64535:34;64553:7;64562:6;64535:17;:34::i;68732:180::-:0;68794:8;:15;68777:14;68820:85;68848:6;68842:3;:12;68820:85;;;68878:15;68889:3;68878:10;:15::i;:::-;68856:5;;;:::i;:::-;;;68820:85;;67014:304;2193:13;:11;:13::i;:::-;67112:11:::1;67108:61;;;67140:17;:15;:17::i;:::-;67197:63;67248:11;67197:46;67217:8;67226:4;67217:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;67197:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;67179:15;:81;;;;67299:11;67271:8;67280:4;67271:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;67014:304:::0;;;:::o;2955:103::-;2193:13;:11;:13::i;:::-;3020:30:::1;3047:1;3020:18;:30::i;:::-;2955:103::o:0;64585:120::-;64637:4;64661:36;64684:7;64693:3;64661:22;:36::i;64085:128::-;2193:13;:11;:13::i;:::-;64155:17:::1;:15;:17::i;:::-;64183:8;:22:::0;64085:128::o;68068:581::-;68139:7;;;68205:23;68211:16;68205:5;:23::i;:::-;68193:35;;68239:9;68251:19;68257:12;68251:5;:19::i;:::-;68239:31;;68281:228;68292:1;68288;:5;68281:228;;;68310:3;;;;:::i;:::-;;;;68328:9;68340:36;68365:10;;68340:20;68346:13;;68340:1;:5;;:20;;;;:::i;:36::-;68328:48;;68405:57;68421:40;68451:9;68458:1;68451:6;:9::i;:::-;68422:23;:1;68428:16;68422:5;:23::i;:::-;68421:29;;:40::i;:::-;68405:11;;:15;:57::i;:::-;68496:1;;-1:-1:-1;68391:71:0;-1:-1:-1;68281:228:0;;;68533:79;68549:62;68590:20;68597:12;68590:6;:20::i;:::-;68550:34;:12;68567:16;68550;:34::i;68549:62::-;68533:11;;:15;:79::i;:::-;68519:93;68068:581;-1:-1:-1;;;;;68068:581:0:o;9769:104::-;9825:13;9858:7;9851:14;;;;;:::i;14127:436::-;14220:4;932:10;14220:4;14303:25;932:10;14320:7;14303:9;:25::i;:::-;14276:52;;14367:15;14347:16;:35;;14339:85;;;;-1:-1:-1;;;14339:85:0;;9275:2:1;14339:85:0;;;9257:21:1;9314:2;9294:18;;;9287:30;9353:34;9333:18;;;9326:62;-1:-1:-1;;;9404:18:1;;;9397:35;9449:19;;14339:85:0;9073:401:1;14339:85:0;14460:60;14469:5;14476:7;14504:15;14485:16;:34;14460:8;:60::i;11174:193::-;11253:4;932:10;11309:28;932:10;11326:2;11330:6;11309:9;:28::i;67878:182::-;67936:7;67956:14;67973:18;67979:11;67973:5;:18::i;:::-;67956:35;;68009:43;68039:12;64289:8;:15;;64219:93;68039:12;68009:25;68022:11;68027:6;68022:1;:11;:::i;:::-;68009:8;;;:12;:25::i;:43::-;68002:50;67878:182;-1:-1:-1;;;67878:182:0:o;65385:670::-;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;65487:26:0;::::1;::::0;;::::1;::::0;:55:::1;;-1:-1:-1::0;;;;;;65517:25:0;::::1;::::0;::::1;65487:55;65479:87;;;::::0;-1:-1:-1;;;65479:87:0;;11055:2:1;65479:87:0::1;::::0;::::1;11037:21:1::0;11094:2;11074:18;;;11067:30;-1:-1:-1;;;11113:18:1;;;11106:49;11172:18;;65479:87:0::1;10853:343:1::0;65479:87:0::1;65585:6;::::0;::::1;;:14;;:6:::0;:14:::1;65577:47;;;::::0;-1:-1:-1;;;65577:47:0;;11403:2:1;65577:47:0::1;::::0;::::1;11385:21:1::0;11442:2;11422:18;;;11415:30;-1:-1:-1;;;11461:18:1;;;11454:50;11521:18;;65577:47:0::1;11201:344:1::0;65577:47:0::1;65635:11;:26:::0;;-1:-1:-1;;;;;65635:26:0;;::::1;-1:-1:-1::0;;;;;;65635:26:0;;::::1;;::::0;;;65672:10:::1;:24:::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;65635:11:::1;65724:17;:15;:17::i;:::-;65707:34;;65752:296;65759:10:::0;;65752:296:::1;;65786:16;65805:28;65822:7;65831:1;65805:16;:28::i;:::-;-1:-1:-1::0;;;;;65862:17:0;;::::1;65848:11;65862:17:::0;;;:7:::1;:17;::::0;;;;;;;;65909:10:::1;::::0;65939:19;;;:14:::1;:19:::0;;;;;;;;65894:65;;-1:-1:-1;;;65894:65:0;;65786:47;;-1:-1:-1;65862:17:0;;65909:10;::::1;::::0;65894:44:::1;::::0;:65:::1;::::0;::::1;;816:25:1::0;;;804:2;789:18;;670:177;65894:65:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;65974:39;65995:7;66004:8;65974:20;:39::i;:::-;-1:-1:-1::0;66028:8:0;::::1;::::0;::::1;:::i;:::-;;;;65771:277;;65752:296;;67393:178:::0;2193:13;:11;:13::i;:::-;67501:1:::1;67486:12;64289:8:::0;:15;;64219:93;67486:12:::1;:16;;;;:::i;:::-;67478:4;:24;;67470:55;;;::::0;-1:-1:-1;;;67470:55:0;;11893:2:1;67470:55:0::1;::::0;::::1;11875:21:1::0;11932:2;11912:18;;;11905:30;-1:-1:-1;;;11951:18:1;;;11944:48;12009:18;;67470:55:0::1;11691:342:1::0;67470:55:0::1;67536:20;::::0;;;:14:::1;:20;::::0;;;;;:27;67393:178::o;65040:72::-;2193:13;:11;:13::i;:::-;65098:6:::1;::::0;;-1:-1:-1;;65088:16:0;::::1;65098:6;::::0;;::::1;65097:7;65088:16;::::0;;65040:72::o;11430:151::-;-1:-1:-1;;;;;11546:18:0;;;11519:7;11546:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11430:151::o;72835:322::-;80790:6;;;;80789:7;80781:45;;;;-1:-1:-1;;;80781:45:0;;;;;;;:::i;:::-;63947:10:::1;::::0;63916:12:::1;::::0;63947:15;-1:-1:-1;63947:15:0;::::1;::::0;:32:::1;;;63971:8;;63966:1;:13;;63947:32;63939:66;;;::::0;-1:-1:-1;;;63939:66:0;;12240:2:1;63939:66:0::1;::::0;::::1;12222:21:1::0;12279:2;12259:18;;;12252:30;-1:-1:-1;;;12298:18:1;;;12291:51;12359:18;;63939:66:0::1;12038:345:1::0;63939:66:0::1;72920:21:::2;72944:8;72953:4;72944:14;;;;;;;;:::i;:::-;;::::0;;;::::2;::::0;;;::::2;::::0;;::::2;;72990:12:::0;;72944:14;;-1:-1:-1;72973:31:0::2;::::0;-1:-1:-1;;;;;72990:12:0::2;72973:8;:31::i;:::-;72969:181;;;73021:46;73041:4;73047:7;73056:10;73021:19;:46::i;:::-;72969:181;;;73100:38;73112:4;73118:7;73127:10;73100:11;:38::i;:::-;72909:248;63893:132:::1;72835:322:::0;;:::o;70061:439::-;70130:7;70139;70158:21;70182:8;70191:4;70182:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;70228:12;;70182:14;;-1:-1:-1;70211:31:0;;-1:-1:-1;;;;;70228:12:0;70211:8;:31::i;:::-;70207:286;;;70260:14;70276:19;70299:32;70319:4;70325:5;70299:19;:32::i;:::-;70259:72;;-1:-1:-1;70259:72:0;-1:-1:-1;70346:28:0;;-1:-1:-1;;;70346:28:0;70207:286;70407:14;70424:24;70436:4;70442:5;70424:11;:24::i;:::-;70407:41;-1:-1:-1;70479:1:0;;-1:-1:-1;70463:18:0;;-1:-1:-1;;70463:18:0;70207:286;70147:353;70061:439;;;;;;:::o;64713:112::-;64761:7;64788:29;64809:7;64788:20;:29::i;:::-;64781:36;;64713:112;:::o;65120:257::-;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;65218:26:0;::::1;::::0;;::::1;::::0;:55:::1;;-1:-1:-1::0;;;;;;65248:25:0;::::1;::::0;::::1;65218:55;65210:87;;;::::0;-1:-1:-1;;;65210:87:0;;11055:2:1;65210:87:0::1;::::0;::::1;11037:21:1::0;11094:2;11074:18;;;11067:30;-1:-1:-1;;;11113:18:1;;;11106:49;11172:18;;65210:87:0::1;10853:343:1::0;65210:87:0::1;65308:11;:26:::0;;-1:-1:-1;;;;;65308:26:0;;::::1;-1:-1:-1::0;;;;;;65308:26:0;;::::1;;::::0;;;65345:10:::1;:24:::0;;;;;::::1;::::0;::::1;;::::0;;65120:257::o;3213:201::-;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;3302:22:0;::::1;3294:73;;;::::0;-1:-1:-1;;;3294:73:0;;12590:2:1;3294:73:0::1;::::0;::::1;12572:21:1::0;12629:2;12609:18;;;12602:30;12668:34;12648:18;;;12641:62;-1:-1:-1;;;12719:18:1;;;12712:36;12765:19;;3294:73:0::1;12388:402:1::0;3294:73:0::1;3378:28;3397:8;3378:18;:28::i;:::-;3213:201:::0;:::o;63725:141::-;2193:13;:11;:13::i;:::-;-1:-1:-1;;;;;63791:18:0;::::1;63783:54;;;::::0;-1:-1:-1;;;63783:54:0;;12997:2:1;63783:54:0::1;::::0;::::1;12979:21:1::0;13036:2;13016:18;;;13009:30;13075:25;13055:18;;;13048:53;13118:18;;63783:54:0::1;12795:347:1::0;63783:54:0::1;63848:3;:10:::0;;-1:-1:-1;;;;;;63848:10:0::1;-1:-1:-1::0;;;;;63848:10:0;;;::::1;::::0;;;::::1;::::0;;63725:141::o;80960:307::-;80903:10;;80891:9;;:22;80883:51;;;;-1:-1:-1;;;80883:51:0;;13349:2:1;80883:51:0;;;13331:21:1;13388:2;13368:18;;;13361:30;-1:-1:-1;;;13407:18:1;;;13400:46;13463:18;;80883:51:0;13147:340:1;80883:51:0;81031:33:::1;81044:4;81050:1;81053:10;81031:12;:33::i;:::-;81104:10;::::0;81089::::1;10915:7:::0;10942:18;;;:9;:18;;;;;;81079:35:::1;81075:185;;81131:29;81137:10;81149;;81131:5;:29::i;:::-;81187:9;::::0;:16:::1;::::0;81201:1:::1;81187:13;:16::i;:::-;81175:9;:28:::0;81227:3:::1;::::0;81218:30:::1;::::0;-1:-1:-1;;;81218:30:0;;81237:10:::1;81218:30;::::0;::::1;3653:51:1::0;-1:-1:-1;;;;;81227:3:0;;::::1;::::0;81218:18:::1;::::0;3626::1;;81218:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;80960:307:::0;:::o;18154:380::-;-1:-1:-1;;;;;18290:19:0;;18282:68;;;;-1:-1:-1;;;18282:68:0;;13694:2:1;18282:68:0;;;13676:21:1;13733:2;13713:18;;;13706:30;13772:34;13752:18;;;13745:62;-1:-1:-1;;;13823:18:1;;;13816:34;13867:19;;18282:68:0;13492:400:1;18282:68:0;-1:-1:-1;;;;;18369:21:0;;18361:68;;;;-1:-1:-1;;;18361:68:0;;14099:2:1;18361:68:0;;;14081:21:1;14138:2;14118:18;;;14111:30;14177:34;14157:18;;;14150:62;-1:-1:-1;;;14228:18:1;;;14221:32;14270:19;;18361:68:0;13897:398:1;18361:68:0;-1:-1:-1;;;;;18442:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18494:32;;816:25:1;;;18494:32:0;;789:18:1;18494:32:0;;;;;;;18154:380;;;:::o;43276:98::-;43334:7;43361:5;43365:1;43361;:5;:::i;44032:98::-;44090:7;44117:5;44121:1;44117;:5;:::i;2472:132::-;2353:7;2380:6;-1:-1:-1;;;;;2380:6:0;932:10;2536:23;2528:68;;;;-1:-1:-1;;;2528:68:0;;14724:2:1;2528:68:0;;;14706:21:1;;;14743:18;;;14736:30;14802:34;14782:18;;;14775:62;14854:18;;2528:68:0;14522:356:1;42895:98:0;42953:7;42980:5;42984:1;42980;:5;:::i;18825:453::-;18960:24;18987:25;18997:5;19004:7;18987:9;:25::i;:::-;18960:52;;-1:-1:-1;;19027:16:0;:37;19023:248;;19109:6;19089:16;:26;;19081:68;;;;-1:-1:-1;;;19081:68:0;;15085:2:1;19081:68:0;;;15067:21:1;15124:2;15104:18;;;15097:30;15163:31;15143:18;;;15136:59;15212:18;;19081:68:0;14883:353:1;19081:68:0;19193:51;19202:5;19209:7;19237:6;19218:16;:25;19193:8;:51::i;15033:840::-;-1:-1:-1;;;;;15164:18:0;;15156:68;;;;-1:-1:-1;;;15156:68:0;;15443:2:1;15156:68:0;;;15425:21:1;15482:2;15462:18;;;15455:30;15521:34;15501:18;;;15494:62;-1:-1:-1;;;15572:18:1;;;15565:35;15617:19;;15156:68:0;15241:401:1;15156:68:0;-1:-1:-1;;;;;15243:16:0;;15235:64;;;;-1:-1:-1;;;15235:64:0;;15849:2:1;15235:64:0;;;15831:21:1;15888:2;15868:18;;;15861:30;15927:34;15907:18;;;15900:62;-1:-1:-1;;;15978:18:1;;;15971:33;16021:19;;15235:64:0;15647:399:1;15235:64:0;-1:-1:-1;;;;;15385:15:0;;15363:19;15385:15;;;:9;:15;;;;;;15419:21;;;;15411:72;;;;-1:-1:-1;;;15411:72:0;;16253:2:1;15411:72:0;;;16235:21:1;16292:2;16272:18;;;16265:30;16331:34;16311:18;;;16304:62;-1:-1:-1;;;16382:18:1;;;16375:36;16428:19;;15411:72:0;16051:402:1;15411:72:0;-1:-1:-1;;;;;15519:15:0;;;;;;;:9;:15;;;;;;15537:20;;;15519:38;;15737:13;;;;;;;;;;:23;;;;;;15789:26;;;;;;15551:6;816:25:1;;804:2;789:18;;670:177;15789:26:0;;;;;;;;15828:37;76229:315;56940:158;57014:7;57065:22;57069:3;57081:5;57065:3;:22::i;76552:1517::-;76647:21;76671:8;76680:4;76671:14;;;;;;;;:::i;:::-;;;;;;;;;76720;;;:8;:14;;;;;;-1:-1:-1;;;;;76720:21:0;;;;;;;;;76760:11;;76671:14;;;;;;;;-1:-1:-1;76760:22:0;-1:-1:-1;76760:22:0;76752:65;;;;-1:-1:-1;;;76752:65:0;;16660:2:1;76752:65:0;;;16642:21:1;16699:2;16679:18;;;16672:30;16738:32;16718:18;;;16711:60;16788:18;;76752:65:0;16458:354:1;76752:65:0;76828:16;76839:4;76828:10;:16::i;:::-;76855:21;76879:64;76927:4;:15;;;76879:43;76917:4;76879:33;76895:4;:16;;;76879:4;:11;;;:15;;:33;;;;:::i;:64::-;76855:88;-1:-1:-1;76958:17:0;;76954:88;;76992:38;77009:5;77016:13;76992:16;:38::i;:::-;77056:11;;77052:808;;77113:11;;77106:44;;-1:-1:-1;;;77106:44:0;;77144:4;77106:44;;;3653:51:1;77084:19:0;;-1:-1:-1;;;;;77113:11:0;;77106:29;;3626:18:1;;77106:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77180:10;;;77201:20;;;:14;:20;;;;;;;;77165:66;;-1:-1:-1;;;77165:66:0;;;;;5813:25:1;;;;5854:18;;;5847:34;;;77084:66:0;;-1:-1:-1;;;;;;77180:10:0;;77165:35;;5786:18:1;;77165:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;77274:11:0;;77267:44;;-1:-1:-1;;;77267:44:0;;77305:4;77267:44;;;3653:51:1;77246:18:0;;-1:-1:-1;;;;;;77274:11:0;;;;-1:-1:-1;77267:29:0;;3626:18:1;;77267:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77246:65;;77351:87;77378:59;77420:4;:16;;;77378:37;77410:4;77378:27;77393:11;77378:10;:14;;:27;;;;:::i;:59::-;77351:22;;;;;:26;:87::i;:::-;77326:22;;;:112;;;77530:21;;;;77476:11;;77453:20;;77476:76;;77530:21;77476:49;;77520:4;;77476:39;;:15;:39::i;:76::-;77453:99;-1:-1:-1;77571:16:0;;77567:110;;77615:11;;77608:53;;-1:-1:-1;;;;;77615:11:0;77641:5;77648:12;77608:32;:53::i;:::-;77705:11;;:24;;77721:7;77705:15;:24::i;:::-;77691:38;;77763:16;;;;:29;;77784:7;77763:20;:29::i;:::-;77744:16;;;:48;77807:12;;:41;;-1:-1:-1;;;;;77807:12:0;77833:5;77840:7;77807:25;:41::i;:::-;77069:791;;;77052:808;77904:16;;;;77888:11;;:43;;77926:4;;77888:33;;:15;:33::i;:43::-;77870:15;;;:61;77982:22;;;;77966:11;;:49;;78010:4;;77966:39;;:15;:39::i;:49::-;77942:21;;;:73;78031:30;;816:25:1;;;78047:4:0;;-1:-1:-1;;;;;78031:30:0;;;;;804:2:1;789:18;78031:30:0;;;;;;;;76636:1433;;;76552:1517;;;:::o;78077:810::-;78164:21;78188:8;78197:4;78188:14;;;;;;;;:::i;:::-;;;;;;;;;78237;;;:8;:14;;;;;;-1:-1:-1;;;;;78237:21:0;;;;;;;;;78277:11;;78188:14;;;;;;;;-1:-1:-1;78277:22:0;-1:-1:-1;78277:22:0;78269:57;;;;-1:-1:-1;;;78269:57:0;;17019:2:1;78269:57:0;;;17001:21:1;17058:2;17038:18;;;17031:30;-1:-1:-1;;;17077:18:1;;;17070:52;17139:18;;78269:57:0;16817:346:1;78269:57:0;78337:16;78348:4;78337:10;:16::i;:::-;78364:21;78388:64;78436:4;:15;;;78388:43;78426:4;78388:33;78404:4;:16;;;78388:4;:11;;;:15;;:33;;;;:::i;:64::-;78364:88;-1:-1:-1;78467:17:0;;78463:88;;78501:38;78518:5;78525:13;78501:16;:38::i;:::-;78565:11;;78561:201;;78607:11;;:24;;78623:7;78607:15;:24::i;:::-;78593:38;;78665:16;;;;:29;;78686:7;78665:20;:29::i;:::-;78646:16;;;:48;78709:12;;:41;;-1:-1:-1;;;;;78709:12:0;78735:5;78742:7;78709:25;:41::i;:::-;78806:16;;;;78790:11;;:43;;78828:4;;78790:33;;:15;:33::i;:43::-;78772:15;;;:61;78849:30;;816:25:1;;;78865:4:0;;-1:-1:-1;;;;;78849:30:0;;;;;804:2:1;789:18;78849:30:0;670:177:1;43633:98:0;43691:7;43718:5;43722:1;43718;:5;:::i;79273:799::-;79360:21;79384:8;79393:4;79384:14;;;;;;;;:::i;:::-;;;;;;;;;79433;;;:8;:14;;;;;;-1:-1:-1;;;;;79433:21:0;;;;;;;;;;79482:11;;79533;;79526:44;;-1:-1:-1;;;79526:44:0;;79564:4;79526:44;;;3653:51:1;79384:14:0;;;;;;;;;-1:-1:-1;79433:21:0;79482:11;;79384:14;;79533:11;;79526:29;;3626:18:1;;79526:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79596:10;;;79617:20;;;:14;:20;;;;;;;;79581:65;;-1:-1:-1;;;79581:65:0;;;;;5813:25:1;;;;5854:18;;;5847:34;;;79504:66:0;;-1:-1:-1;;;;;;79596:10:0;;79581:35;;5786:18:1;;79581:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;79685:11:0;;79678:44;;-1:-1:-1;;;79678:44:0;;79716:4;79678:44;;;3653:51:1;79657:18:0;;-1:-1:-1;;;;;;79685:11:0;;;;-1:-1:-1;79678:29:0;;3626:18:1;;79678:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79657:65;;79758:87;79785:59;79827:4;:16;;;79785:37;79817:4;79785:27;79800:11;79785:10;:14;;:27;;;;:::i;79758:87::-;79733:22;;;:112;79870:1;79856:15;;;79882;;;:19;79912:12;;:40;;-1:-1:-1;;;;;79912:12:0;79938:5;79945:6;79912:25;:40::i;:::-;79982:16;;;;:28;;80003:6;79982:20;:28::i;:::-;79963:16;;;:47;80026:38;;816:25:1;;;80051:4:0;;-1:-1:-1;;;;;80026:38:0;;;;;804:2:1;789:18;80026:38:0;;;;;;;79349:723;;;;;79273:799;;:::o;80080:439::-;80159:21;80183:8;80192:4;80183:14;;;;;;;;:::i;:::-;;;;;;;;;80232;;;:8;:14;;;;;;-1:-1:-1;;;;;80232:21:0;;;;;;;;;80281:11;;80303:15;;;-1:-1:-1;80329:15:0;;:19;;;;80183:14;;;;;80359:12;;80183:14;;-1:-1:-1;80232:21:0;;80281:11;80359:40;;:12;80247:5;80281:11;80359:25;:40::i;:::-;80429:16;;;;:28;;80450:6;80429:20;:28::i;:::-;80410:16;;;:47;80473:38;;816:25:1;;;80498:4:0;;-1:-1:-1;;;;;80473:38:0;;;;;804:2:1;789:18;80473:38:0;;;;;;;;80148:371;;;80080:439;;:::o;55644:152::-;55714:4;55738:50;55743:3;-1:-1:-1;;;;;55763:23:0;;55738:4;:50::i;3574:191::-;3648:16;3667:6;;-1:-1:-1;;;;;3684:17:0;;;-1:-1:-1;;;;;;3684:17:0;;;;;;3717:40;;3667:6;;;;;;;3717:40;;3648:16;3717:40;3637:128;3574:191;:::o;56216:167::-;-1:-1:-1;;;;;56350:23:0;;56296:4;51568:19;;;:12;;;:19;;;;;;:24;;56320:55;51471:129;55972:158;56045:4;56069:53;56077:3;-1:-1:-1;;;;;56097:23:0;;56069:7;:53::i;73165:2189::-;73259:21;73283:8;73292:4;73283:14;;;;;;;;:::i;:::-;;;;;;;;;73332;;;:8;:14;;;;;;-1:-1:-1;;;;;73332:21:0;;;;;;;;;73283:14;;;;;;;;-1:-1:-1;73364:16:0;73341:4;73364:10;:16::i;:::-;73395:11;;:15;73391:846;;73427:21;73451:64;73499:4;:15;;;73451:43;73489:4;73451:33;73467:4;:16;;;73451:4;:11;;;:15;;:33;;;;:::i;:64::-;73427:88;-1:-1:-1;73534:17:0;;73530:96;;73572:38;73589:5;73596:13;73572:16;:38::i;:::-;73669:11;;73662:44;;-1:-1:-1;;;73662:44:0;;73700:4;73662:44;;;3653:51:1;73640:19:0;;-1:-1:-1;;;;;73669:11:0;;73662:29;;3626:18:1;;73662:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73736:10;;;73756:20;;;:14;:20;;;;;;;73721:59;;-1:-1:-1;;;73721:59:0;;;;;5813:25:1;;;;5854:18;;;5847:34;;;;73640:66:0;;-1:-1:-1;;;;;;73736:10:0;;73721:34;;5786:18:1;;73721:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73823:11:0;;73816:44;;-1:-1:-1;;;73816:44:0;;73854:4;73816:44;;;3653:51:1;73795:18:0;;-1:-1:-1;;;;;;73823:11:0;;;;-1:-1:-1;73816:29:0;;3626:18:1;;73816:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73795:65;;73900:87;73927:59;73969:4;:16;;;73927:37;73959:4;73927:27;73942:11;73927:10;:14;;:27;;;;:::i;73900:87::-;73875:22;;;:112;;;74079:21;;;;74025:11;;74002:20;;74025:76;;74079:21;74025:49;;74069:4;;74025:39;;:15;:39::i;:76::-;74002:99;-1:-1:-1;74120:16:0;;74116:110;;74164:11;;74157:53;;-1:-1:-1;;;;;74164:11:0;74190:5;74197:12;74157:32;:53::i;:::-;73412:825;;;;73391:846;74251:11;;74247:899;;74279:12;;:60;;-1:-1:-1;;;;;74279:12:0;74309:5;74324:4;74331:7;74279:29;:60::i;:::-;74358:4;:16;;;74378:1;74358:21;74354:781;;74415:10;;;74435:20;;;:14;:20;;;;;;;;74400:65;;-1:-1:-1;;;74400:65:0;;-1:-1:-1;;;;;74415:10:0;;;;74400:34;;:65;;74457:7;;74400:65;;5813:25:1;;;5869:2;5854:18;;5847:34;5801:2;5786:18;;5639:248;74400:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;74498:11:0;;:24;;-1:-1:-1;74498:11:0;-1:-1:-1;74514:7:0;74498:15;:24::i;:::-;74484:38;;74560:16;;;;:29;;74581:7;74560:20;:29::i;:::-;74541:16;;;:48;74354:781;;;74659:11;;74652:44;;-1:-1:-1;;;74652:44:0;;74690:4;74652:44;;;3653:51:1;74630:19:0;;-1:-1:-1;;;;;74659:11:0;;74652:29;;3626:18:1;;74652:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74730:10;;;74750:20;;;:14;:20;;;;;;;;74715:65;;-1:-1:-1;;;74715:65:0;;;;;5813:25:1;;;;5854:18;;;5847:34;;;74630:66:0;;-1:-1:-1;;;;;;74730:10:0;;74715:34;;5786:18:1;;74715:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;74827:11:0;;74820:44;;-1:-1:-1;;;74820:44:0;;74858:4;74820:44;;;3653:51:1;74799:18:0;;-1:-1:-1;;;;;;74827:11:0;;;;-1:-1:-1;74820:29:0;;3626:18:1;;74820:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74799:65;;74908:87;74935:59;74977:4;:16;;;74935:37;74967:4;74935:27;74950:11;74935:10;:14;;:27;;;;:::i;:59::-;74908:22;;;;;:26;:87::i;:::-;74883:22;;;:112;75028:11;;:24;;75044:7;75028:15;:24::i;:::-;75014:38;;75090:16;;;;:29;;75111:7;75090:20;:29::i;:::-;75071:16;;;:48;-1:-1:-1;;74354:781:0;75190:16;;;;75174:11;;:43;;75212:4;;75174:33;;:15;:33::i;:43::-;75156:15;;;:61;75268:22;;;;75252:11;;:49;;75296:4;;75252:39;;:15;:39::i;:49::-;75228:21;;;:73;75317:29;;816:25:1;;;75332:4:0;;-1:-1:-1;;;;;75317:29:0;;;;;804:2:1;789:18;75317:29:0;670:177:1;75362:818:0;75448:21;75472:8;75481:4;75472:14;;;;;;;;:::i;:::-;;;;;;;;;75521;;;:8;:14;;;;;;-1:-1:-1;;;;;75521:21:0;;;;;;;;;75472:14;;;;;;;;-1:-1:-1;75553:16:0;75530:4;75553:10;:16::i;:::-;75584:11;;:15;75580:246;;75616:21;75640:64;75688:4;:15;;;75640:43;75678:4;75640:33;75656:4;:16;;;75640:4;:11;;;:15;;:33;;;;:::i;:64::-;75616:88;-1:-1:-1;75723:17:0;;75719:96;;75761:38;75778:5;75785:13;75761:16;:38::i;:::-;75601:225;75580:246;75840:11;;75836:220;;75868:12;;:60;;-1:-1:-1;;;;;75868:12:0;75898:5;75913:4;75920:7;75868:29;:60::i;:::-;75957:11;;:24;;75973:7;75957:15;:24::i;:::-;75943:38;;76015:16;;;;:29;;76036:7;76015:20;:29::i;:::-;75996:16;;;:48;75836:220;76100:16;;;;76084:11;;:43;;76122:4;;76084:33;;:15;:33::i;:43::-;76066:15;;;:61;76143:29;;816:25:1;;;76158:4:0;;-1:-1:-1;;;;;76143:29:0;;;;;804:2:1;789:18;76143:29:0;670:177:1;70508:1315:0;70588:7;70597;70616:21;70640:8;70649:4;70640:14;;;;;;;;:::i;:::-;;;;;;;;;70689;;;:8;:14;;;;;;-1:-1:-1;;;;;70689:21:0;;;;;;;;;70743:16;70640:14;;;;;;;70743:16;;;;70798:22;;;;70835:11;;70640:14;;-1:-1:-1;70743:16:0;;70835:15;70831:961;;70905:10;;70867:20;70929;;;:14;:20;;;;;;;70890:75;;-1:-1:-1;;;70890:75:0;;;;;17776:25:1;;;;70959:4:0;17817:18:1;;;17810:60;70867:20:0;;-1:-1:-1;;;;;70905:10:0;;70890:38;;17749:18:1;;70890:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70867:98;;71000:67;71022:44;71049:4;:16;;;71022:22;71039:4;71022:12;:16;;:22;;;;:::i;:44::-;71000:17;;:21;:67::i;:::-;70980:87;;71082:19;71104:71;71153:4;:21;;;71104:44;71143:4;71104:34;71120:17;71104:4;:11;;;:15;;:34;;;;:::i;:71::-;71082:93;;71209:4;:20;;;71194:12;:35;71190:419;;;71250:19;71272:36;71287:4;:20;;;71272:14;:36::i;:::-;71250:58;;71327:18;71348:53;71385:15;;71348:32;71364:4;:15;;;71348:11;:15;;:32;;;;:::i;:53::-;71327:74;;71434:59;71450:42;71475:4;:16;;;71450:20;71465:4;71450:10;:14;;:20;;;;:::i;:42::-;71434:11;;:15;:59::i;:::-;71420:73;;71520:59;71563:4;:15;;;71520:38;71553:4;71520:28;71536:11;71520:4;:11;;;:15;;:28;;;;:::i;:59::-;71581:11;71512:81;;;;;;;;;;;;;;71190:419;71643:4;:20;;;71627:12;:36;71623:158;;71692:59;71735:4;:15;;;71692:38;71725:4;71692:28;71708:11;71692:4;:11;;;:15;;:28;;;;:::i;:59::-;71684:81;-1:-1:-1;71753:11:0;-1:-1:-1;71684:81:0;;-1:-1:-1;;;;;71684:81:0;71623:158;70852:940;;70831:961;-1:-1:-1;71810:1:0;;;;-1:-1:-1;70508:1315:0;-1:-1:-1;;;;;;70508:1315:0:o;71831:938::-;71903:7;71922:21;71946:8;71955:4;71946:14;;;;;;;;:::i;:::-;;;;;;;;;71995;;;:8;:14;;;;;;-1:-1:-1;;;;;71995:21:0;;;;;;;;;;71946:14;;;;;;;;72049:16;;;;72095:12;;:37;;-1:-1:-1;;;72095:37:0;;72126:4;72095:37;;;3653:51:1;71946:14:0;;-1:-1:-1;71995:21:0;;71946:14;72095:12;;;;;:22;;3626:18:1;;72095:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72147:11;;72076:56;;-1:-1:-1;72147:15:0;72143:600;;72198:4;:20;;;72183:12;:35;72179:396;;;72239:19;72261:36;72276:4;:20;;;72261:14;:36::i;:::-;72239:58;;72316:18;72337:53;72374:15;;72337:32;72353:4;:15;;;72337:11;:15;;:32;;;;:::i;:53::-;72316:74;-1:-1:-1;72423:51:0;72439:34;72464:8;72439:20;72316:74;72454:4;72439:14;:20::i;72423:51::-;72409:65;;72500:59;72543:4;:15;;;72500:38;72533:4;72500:28;72516:11;72500:4;:11;;;:15;;:28;;;;:::i;:59::-;72493:66;;;;;;;;;;72179:396;72609:4;:20;;;72593:12;:36;72589:143;;72657:59;72700:4;:15;;;72657:38;72690:4;72657:28;72673:11;72657:4;:11;;;:15;;:28;;;;:::i;:59::-;72650:66;;;;;;;;72589:143;-1:-1:-1;72760:1:0;;71831:938;-1:-1:-1;;;;;;71831:938:0:o;56469:117::-;56532:7;56559:19;56567:3;51769:18;;51686:109;17041:675;-1:-1:-1;;;;;17125:21:0;;17117:67;;;;-1:-1:-1;;;17117:67:0;;18083:2:1;17117:67:0;;;18065:21:1;18122:2;18102:18;;;18095:30;18161:34;18141:18;;;18134:62;-1:-1:-1;;;18212:18:1;;;18205:31;18253:19;;17117:67:0;17881:397:1;17117:67:0;-1:-1:-1;;;;;17284:18:0;;17259:22;17284:18;;;:9;:18;;;;;;17321:24;;;;17313:71;;;;-1:-1:-1;;;17313:71:0;;18485:2:1;17313:71:0;;;18467:21:1;18524:2;18504:18;;;18497:30;18563:34;18543:18;;;18536:62;-1:-1:-1;;;18614:18:1;;;18607:32;18656:19;;17313:71:0;18283:398:1;17313:71:0;-1:-1:-1;;;;;17420:18:0;;;;;;:9;:18;;;;;;;;17441:23;;;17420:44;;17559:12;:22;;;;;;;17610:37;816:25:1;;;17420:18:0;;;17610:37;;789:18:1;17610:37:0;;;;;;;76294:250:::1;76229:315:::0;;:::o;52149:120::-;52216:7;52243:3;:11;;52255:5;52243:18;;;;;;;;:::i;:::-;;;;;;;;;52236:25;;52149:120;;;;:::o;80633:109::-;80709:25;80721:3;80726:7;80709:11;:25::i;33267:211::-;33411:58;;-1:-1:-1;;;;;8596:32:1;;33411:58:0;;;8578:51:1;8645:18;;;8638:34;;;33384:86:0;;33404:5;;-1:-1:-1;;;33434:23:0;8551:18:1;;33411:58:0;;;;-1:-1:-1;;33411:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;33411:58:0;-1:-1:-1;;;;;;33411:58:0;;;;;;;;;;33384:19;:86::i;49375:414::-;49438:4;51568:19;;;:12;;;:19;;;;;;49455:327;;-1:-1:-1;49498:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;49681:18;;49659:19;;;:12;;;:19;;;;;;:40;;;;49714:11;;49455:327;-1:-1:-1;49765:5:0;49758:12;;49965:1420;50031:4;50170:19;;;:12;;;:19;;;;;;50206:15;;50202:1176;;50581:21;50605:14;50618:1;50605:10;:14;:::i;:::-;50654:18;;50581:38;;-1:-1:-1;50634:17:0;;50654:22;;50675:1;;50654:22;:::i;:::-;50634:42;;50710:13;50697:9;:26;50693:405;;50744:17;50764:3;:11;;50776:9;50764:22;;;;;;;;:::i;:::-;;;;;;;;;50744:42;;50918:9;50889:3;:11;;50901:13;50889:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;51003:23;;;:12;;;:23;;;;;:36;;;50693:405;51179:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;51274:3;:12;;:19;51287:5;51274:19;;;;;;;;;;;51267:26;;;51317:4;51310:11;;;;;;;50202:1176;51361:5;51354:12;;;;;33486:248;33657:68;;-1:-1:-1;;;;;19076:15:1;;;33657:68:0;;;19058:34:1;19128:15;;19108:18;;;19101:43;19160:18;;;19153:34;;;33630:96:0;;33650:5;;-1:-1:-1;;;33680:27:0;18993:18:1;;33657:68:0;18818:375:1;16160:548:0;-1:-1:-1;;;;;16244:21:0;;16236:65;;;;-1:-1:-1;;;16236:65:0;;19400:2:1;16236:65:0;;;19382:21:1;19439:2;19419:18;;;19412:30;19478:33;19458:18;;;19451:61;19529:18;;16236:65:0;19198:355:1;16236:65:0;16392:6;16376:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16547:18:0;;;;;;:9;:18;;;;;;;;:28;;;;;;16602:37;816:25:1;;;16602:37:0;;789:18:1;16602:37:0;;;;;;;79015:250:::1;78958:307:::0;:::o;36334:716::-;36758:23;36784:69;36812:4;36784:69;;;;;;;;;;;;;;;;;36792:5;-1:-1:-1;;;;;36784:27:0;;;:69;;;;;:::i;:::-;36868:17;;36758:95;;-1:-1:-1;36868:21:0;36864:179;;36965:10;36954:30;;;;;;;;;;;;:::i;:::-;36946:85;;;;-1:-1:-1;;;36946:85:0;;19760:2:1;36946:85:0;;;19742:21:1;19799:2;19779:18;;;19772:30;19838:34;19818:18;;;19811:62;-1:-1:-1;;;19889:18:1;;;19882:40;19939:19;;36946:85:0;19558:406:1;27109:229:0;27246:12;27278:52;27300:6;27308:4;27314:1;27317:12;27278:21;:52::i;:::-;27271:59;27109:229;-1:-1:-1;;;;27109:229:0:o;28229:455::-;28399:12;28457:5;28432:21;:30;;28424:81;;;;-1:-1:-1;;;28424:81:0;;20171:2:1;28424:81:0;;;20153:21:1;20210:2;20190:18;;;20183:30;20249:34;20229:18;;;20222:62;-1:-1:-1;;;20300:18:1;;;20293:36;20346:19;;28424:81:0;19969:402:1;28424:81:0;28517:12;28531:23;28558:6;-1:-1:-1;;;;;28558:11:0;28577:5;28584:4;28558:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28516:73;;;;28607:69;28634:6;28642:7;28651:10;28663:12;28607:26;:69::i;:::-;28600:76;28229:455;-1:-1:-1;;;;;;;28229:455:0:o;30802:644::-;30987:12;31016:7;31012:427;;;31044:10;:17;31065:1;31044:22;31040:290;;-1:-1:-1;;;;;24647:19:0;;;31254:60;;;;-1:-1:-1;;;31254:60:0;;20870:2:1;31254:60:0;;;20852:21:1;20909:2;20889:18;;;20882:30;20948:31;20928:18;;;20921:59;20997:18;;31254:60:0;20668:353:1;31254:60:0;-1:-1:-1;31351:10:0;31344:17;;31012:427;31394:33;31402:10;31414:12;32149:17;;:21;32145:388;;32381:10;32375:17;32438:15;32425:10;32421:2;32417:19;32410:44;32145:388;32508:12;32501:20;;-1:-1:-1;;;32501:20:0;;;;;;;;:::i;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:396::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;649:2;628:15;-1:-1:-1;;624:29:1;609:45;;;;656:2;605:54;;269:396;-1:-1:-1;;269:396:1:o;852:131::-;-1:-1:-1;;;;;927:31:1;;917:42;;907:70;;973:1;970;963:12;988:315;1056:6;1064;1117:2;1105:9;1096:7;1092:23;1088:32;1085:52;;;1133:1;1130;1123:12;1085:52;1172:9;1159:23;1191:31;1216:5;1191:31;:::i;:::-;1241:5;1293:2;1278:18;;;;1265:32;;-1:-1:-1;;;988:315:1:o;1500:180::-;1559:6;1612:2;1600:9;1591:7;1587:23;1583:32;1580:52;;;1628:1;1625;1618:12;1580:52;-1:-1:-1;1651:23:1;;1500:180;-1:-1:-1;1500:180:1:o;2265:118::-;2351:5;2344:13;2337:21;2330:5;2327:32;2317:60;;2373:1;2370;2363:12;2388:464;2476:6;2484;2492;2545:2;2533:9;2524:7;2520:23;2516:32;2513:52;;;2561:1;2558;2551:12;2513:52;2597:9;2584:23;2574:33;;2657:2;2646:9;2642:18;2629:32;2670:31;2695:5;2670:31;:::i;:::-;2720:5;-1:-1:-1;2777:2:1;2762:18;;2749:32;2790:30;2749:32;2790:30;:::i;:::-;2839:7;2829:17;;;2388:464;;;;;:::o;2857:456::-;2934:6;2942;2950;3003:2;2991:9;2982:7;2978:23;2974:32;2971:52;;;3019:1;3016;3009:12;2971:52;3058:9;3045:23;3077:31;3102:5;3077:31;:::i;:::-;3127:5;-1:-1:-1;3184:2:1;3169:18;;3156:32;3197:33;3156:32;3197:33;:::i;:::-;2857:456;;3249:7;;-1:-1:-1;;;3303:2:1;3288:18;;;;3275:32;;2857:456::o;3715:248::-;3783:6;3791;3844:2;3832:9;3823:7;3819:23;3815:32;3812:52;;;3860:1;3857;3850:12;3812:52;-1:-1:-1;;3883:23:1;;;3953:2;3938:18;;;3925:32;;-1:-1:-1;3715:248:1:o;3968:247::-;4027:6;4080:2;4068:9;4059:7;4055:23;4051:32;4048:52;;;4096:1;4093;4086:12;4048:52;4135:9;4122:23;4154:31;4179:5;4154:31;:::i;4220:377::-;4294:6;4302;4310;4363:2;4351:9;4342:7;4338:23;4334:32;4331:52;;;4379:1;4376;4369:12;4331:52;4415:9;4402:23;4392:33;;4472:2;4461:9;4457:18;4444:32;4434:42;;4526:2;4515:9;4511:18;4498:32;4539:28;4561:5;4539:28;:::i;4602:315::-;4670:6;4678;4731:2;4719:9;4710:7;4706:23;4702:32;4699:52;;;4747:1;4744;4737:12;4699:52;4783:9;4770:23;4760:33;;4843:2;4832:9;4828:18;4815:32;4856:31;4881:5;4856:31;:::i;:::-;4906:5;4896:15;;;4602:315;;;;;:::o;5246:388::-;5314:6;5322;5375:2;5363:9;5354:7;5350:23;5346:32;5343:52;;;5391:1;5388;5381:12;5343:52;5430:9;5417:23;5449:31;5474:5;5449:31;:::i;:::-;5499:5;-1:-1:-1;5556:2:1;5541:18;;5528:32;5569:33;5528:32;5569:33;:::i;5892:380::-;5971:1;5967:12;;;;6014;;;6035:61;;6089:4;6081:6;6077:17;6067:27;;6035:61;6142:2;6134:6;6131:14;6111:18;6108:38;6105:161;;6188:10;6183:3;6179:20;6176:1;6169:31;6223:4;6220:1;6213:15;6251:4;6248:1;6241:15;6105:161;;5892:380;;;:::o;6634:127::-;6695:10;6690:3;6686:20;6683:1;6676:31;6726:4;6723:1;6716:15;6750:4;6747:1;6740:15;6766:128;6833:9;;;6854:11;;;6851:37;;;6868:18;;:::i;6899:125::-;6964:9;;;6985:10;;;6982:36;;;6998:18;;:::i;7378:349::-;7580:2;7562:21;;;7619:2;7599:18;;;7592:30;7658:27;7653:2;7638:18;;7631:55;7718:2;7703:18;;7378:349::o;7732:127::-;7793:10;7788:3;7784:20;7781:1;7774:31;7824:4;7821:1;7814:15;7848:4;7845:1;7838:15;7864:184;7934:6;7987:2;7975:9;7966:7;7962:23;7958:32;7955:52;;;8003:1;8000;7993:12;7955:52;-1:-1:-1;8026:16:1;;7864:184;-1:-1:-1;7864:184:1:o;8683:245::-;8750:6;8803:2;8791:9;8782:7;8778:23;8774:32;8771:52;;;8819:1;8816;8809:12;8771:52;8851:9;8845:16;8870:28;8892:5;8870:28;:::i;8933:135::-;8972:3;8993:17;;;8990:43;;9013:18;;:::i;:::-;-1:-1:-1;9060:1:1;9049:13;;8933:135::o;9479:422::-;9568:1;9611:5;9568:1;9625:270;9646:7;9636:8;9633:21;9625:270;;;9705:4;9701:1;9697:6;9693:17;9687:4;9684:27;9681:53;;;9714:18;;:::i;:::-;9764:7;9754:8;9750:22;9747:55;;;9784:16;;;;9747:55;9863:22;;;;9823:15;;;;9625:270;;9906:806;9955:5;9985:8;9975:80;;-1:-1:-1;10026:1:1;10040:5;;9975:80;10074:4;10064:76;;-1:-1:-1;10111:1:1;10125:5;;10064:76;10156:4;10174:1;10169:59;;;;10242:1;10237:130;;;;10149:218;;10169:59;10199:1;10190:10;;10213:5;;;10237:130;10274:3;10264:8;10261:17;10258:43;;;10281:18;;:::i;:::-;-1:-1:-1;;10337:1:1;10323:16;;10352:5;;10149:218;;10451:2;10441:8;10438:16;10432:3;10426:4;10423:13;10419:36;10413:2;10403:8;10400:16;10395:2;10389:4;10386:12;10382:35;10379:77;10376:159;;;-1:-1:-1;10488:19:1;;;10520:5;;10376:159;10567:34;10592:8;10586:4;10567:34;:::i;:::-;10637:6;10633:1;10629:6;10625:19;10616:7;10613:32;10610:58;;;10648:18;;:::i;:::-;10686:20;;9906:806;-1:-1:-1;;;9906:806:1:o;10717:131::-;10777:5;10806:36;10833:8;10827:4;10806:36;:::i;11550:136::-;11589:3;11617:5;11607:39;;11626:18;;:::i;:::-;-1:-1:-1;;;11662:18:1;;11550:136::o;14300:217::-;14340:1;14366;14356:132;;14410:10;14405:3;14401:20;14398:1;14391:31;14445:4;14442:1;14435:15;14473:4;14470:1;14463:15;14356:132;-1:-1:-1;14502:9:1;;14300:217::o;17168:168::-;17241:9;;;17272;;17289:15;;;17283:22;;17269:37;17259:71;;17310:18;;:::i;18686:127::-;18747:10;18742:3;18738:20;18735:1;18728:31;18778:4;18775:1;18768:15;18802:4;18799:1;18792:15;20376:287;20505:3;20543:6;20537:13;20559:66;20618:6;20613:3;20606:4;20598:6;20594:17;20559:66;:::i;:::-;20641:16;;;;;20376:287;-1:-1:-1;;20376:287:1:o

Swarm Source

ipfs://44ba46758f740205340330fc0563e73b13a260af3312bfcaeff7ca84bacd71b9

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