The Warbles (WARBLE) Token Tracker

The Warbles (WARBLE)

Overview

TokenID

248

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract

0x7a494629821bbefb7acaed0a4b31d748db743f93

TokenID: 248

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Warbles

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-12-31
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// 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/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Context.sol


// 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/Ownable.sol


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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts v4.4.1 (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.zeppelin.solutions/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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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;
        _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;
        }
        _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 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/utils/Address.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

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

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` 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 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol


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

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

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

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: warbles.sol


/*
╢╢╢╢╢▓▓╢╢╢╢╢╢▓╣╢╢╢╢╢╢▓╢╢╢╢╢╢▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██████╣▓╣╢╢╢╢╢╢▓╢

╢╢╢╢╢▓▓╢╢╢╢╢╢▓╣╢╢╢╢╢╢▓╢╢╢╢╢╢▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████╣▓╣╢╢╢╢╢╢▓╢

▓▓▓╣╢▓▓╢╢╢╢╢╢▓╣╢╢╢╢╢╢▓╢╢╢╢╢╢▓▓████▓▓▓▓▓█████▓▓▓▓▓▓████▓▓▓▓▓▓▓▓███████╣▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓╢╢╢╢╢▓╣╢╢╢╢╢╢▓╢╢╢╢╢╢▓▓████▓▓███▓█▓▓▓█████▓█▓▓▓██▓▓▓▓▓███████╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓╢▓╣╢╢╢╢╢╢▓╢╢╢╢╢╢▓▓████▓███▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓███████╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓╣╢╢╢╢▓╢╢╢╢╢╢▓▓███████▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓███████╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓╢╢╢╢▓███████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓███████╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓╣██▓▓██████████████████████████████████▓███╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████████████████████████████████████╢╢▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████▀▒▒▒▒▒▒▒▄▄▄▄░▒▒▒▒░▄▄▄▀██▓▓████████╣▓╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████╢▒▒▒▒▒▒▒▀▀▀▀░▒▒▒▒░▀▀▀▒██▓▓█████████╣╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████╢▒▒▒▒▒▒▒▒▒▒▄▄▄▄▄▄▄▄▄▄▄█████████████╣╣╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████╢▒▒▒▒▒▒▒▒▄█▓███████████▓████████████▒╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████╢▒▒▒▒▒▒▒╢██▓███████████████▓████████▌╢╢╢╢╢╢▓╢

▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███████╢▒▒▒▒▒▒▒▒╢▀██████████████████████████▌╢╢╢╢╢▓╢

███████████████████████████████████╢▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒█▓╣▓▓██▓▓███████████████

██▓▓███████▓▓████▓▓████████████████╢▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀█▒╢▓█▓▓▓▀▀█████████████

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██████████╢▒▒▒▒▒▒▒▒█▒▒""""""▒▒▒▒███▓▓▓█╢╢╢███▓█████████

▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████████╢▒▒▒▒▒▒▒▒██        "▒▒████▌▓▓█▓▓▓▓███████████

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██████████████░▒▒▒▒▒▒▒██          ▒███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███░▒▒▒▒▒▒▒██          ▒██▓████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████░▒▒▒▒▒▄██          ▒███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██╢▀█▄▄▄▄▄██           ▒███████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██╢█▓█▓▓████           ▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓██╢▀▀▀▀▀▀▀▀▀           ▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██╢▒▒▒▒▒▒              ▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██╢▒▒▒▒▒▒              ▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████╢▒▒▒▒▒▒╥           m▒▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████╢▒▒▒▒▒▒▒▒▄▄▄▄▄▄▄▄▀╢╢▒▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████████╢▒▒▒▒▒▒▒▒█████▀▒╢╢╢▒▒▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████▓██████╢@▒▒▒▒▒▒▒████▌╢╢╢╣▒▒▒▒██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓████████████████████████▒Ñ▒▒▒▒▒██████▌╢▓▒▒▒▒████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓█████████▓████████████████████▒▒▒▒▒████████▌▌▒▒▒██████████████████▓▓▓▓▓▓▓

▓▓▓▓▓██████████████████████████████████████████▓███████████████████████████▓▓▓▓▓

▓▓▓▓▓▓▓███████████████████████████████████████████████████████████████████▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██████████████████████████████████████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
*/

pragma solidity ^0.8.0;





contract Warbles is ERC721, ERC721Enumerable, Ownable {
    bool public publicMintActive = true;
    string private _baseURIextended;
    string public baseExtension = ".json";



    // Supply and pricing 
    uint256 public constant MAX_SUPPLY = 6969;
    uint8 public constant MAX_PUBLIC_MINT = 10;
    uint256 private _mintPrice = 0.04 ether;

     /**
     * @notice Mint warble 
     * @param numberOfTokens number of warbles to mint
     */
    function mint(uint8 numberOfTokens) public payable {
        uint256 ts = totalSupply();
        require(publicMintActive, "mint not active");
        require(numberOfTokens <= MAX_PUBLIC_MINT, "exceed max tokens");
        require(ts + numberOfTokens <= MAX_SUPPLY, "exceeds supply");
        require(_mintPrice * numberOfTokens <= msg.value, "wrong value");

        // i = 1 because tokenId starts at 1
        for (uint8 i = 1; i <= numberOfTokens; i++) {
            _mint(msg.sender, ts + i); 
        }
    }


    // treasury
    address treasuryAddress = 0x9cC57fD8da348AB662C39bF826fCDd4D4887ab79;

    constructor( string memory _initBaseURI) ERC721("The Warbles", "WARBLE") {
        setBaseURI(_initBaseURI);
        // preallocate 40 warbles for airdrop
        for (uint256 i = 1; i <= 55; i++) {
            _mint( treasuryAddress, i);
        }
    }


    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function setBaseURI(string memory baseURI_) public onlyOwner() {
        _baseURIextended = baseURI_;
    }

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

    /**
     * @notice Start/Stop public mint
     * @param newState set to true to start public mint
     */
    function setPublicMintActive(bool newState) public onlyOwner {
        publicMintActive = newState;
    }

     /**
     * @notice Set Mint Price
     * @param newPrice mint price if neccessary
     */
    function setMintPrice(uint256 newPrice) external onlyOwner {
        _mintPrice = newPrice;
    }

    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_initBaseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_PUBLIC_MINT","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"numberOfTokens","type":"uint8"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMintActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newState","type":"bool"}],"name":"setPublicMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"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)

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d59757a4b7342487062425141667a5969715078476e7a6347566558664a7154453641434e4d414434786148312f00000000000000000000

-----Decoded View---------------
Arg [0] : _initBaseURI (string): ipfs://QmYuzKsBHpbBQAfzYiqPxGnzcGVeXfJqTE6ACNMAD4xaH1/

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [2] : 697066733a2f2f516d59757a4b7342487062425141667a5969715078476e7a63
Arg [3] : 47566558664a7154453641434e4d414434786148312f00000000000000000000

Deployed Bytecode Sourcemap

68751:2566:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70308:179;;;;;;;;;;-1:-1:-1;70308:179:0;;;;;:::i;:::-;;:::i;:::-;;;6177:14:1;;6170:22;6152:41;;6140:2;6125:18;70308:179:0;;;;;;;;41483:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;43042:221::-;;;;;;;;;;-1:-1:-1;43042:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5475:32:1;;;5457:51;;5445:2;5430:18;43042:221:0;5311:203:1;42565:411:0;;;;;;;;;;-1:-1:-1;42565:411:0;;;;;:::i;:::-;;:::i;:::-;;54629:113;;;;;;;;;;-1:-1:-1;54717:10:0;:17;54629:113;;;15154:25:1;;;15142:2;15127:18;54629:113:0;15008:177:1;43792:339:0;;;;;;;;;;-1:-1:-1;43792:339:0;;;;;:::i;:::-;;:::i;70851:107::-;;;;;;;;;;-1:-1:-1;70851:107:0;;;;;:::i;:::-;;:::i;54297:256::-;;;;;;;;;;-1:-1:-1;54297:256:0;;;;;:::i;:::-;;:::i;68970:41::-;;;;;;;;;;;;69007:4;68970:41;;71172:140;;;;;;;;;;;;;:::i;44202:185::-;;;;;;;;;;-1:-1:-1;44202:185:0;;;;;:::i;:::-;;:::i;54819:233::-;;;;;;;;;;-1:-1:-1;54819:233:0;;;;;:::i;:::-;;:::i;70495:109::-;;;;;;;;;;-1:-1:-1;70495:109:0;;;;;:::i;:::-;;:::i;41177:239::-;;;;;;;;;;-1:-1:-1;41177:239:0;;;;;:::i;:::-;;:::i;69018:42::-;;;;;;;;;;;;69058:2;69018:42;;;;;15362:4:1;15350:17;;;15332:36;;15320:2;15305:18;69018:42:0;15190:184:1;69219:526:0;;;;;;:::i;:::-;;:::i;40907:208::-;;;;;;;;;;-1:-1:-1;40907:208:0;;;;;:::i;:::-;;:::i;8361:103::-;;;;;;;;;;;;;:::i;7710:87::-;;;;;;;;;;-1:-1:-1;7783:6:0;;-1:-1:-1;;;;;7783:6:0;7710:87;;41652:104;;;;;;;;;;;;;:::i;43335:155::-;;;;;;;;;;-1:-1:-1;43335:155:0;;;;;:::i;:::-;;:::i;68812:35::-;;;;;;;;;;-1:-1:-1;68812:35:0;;;;-1:-1:-1;;;68812:35:0;;;;;;44458:328;;;;;;;;;;-1:-1:-1;44458:328:0;;;;;:::i;:::-;;:::i;68892:37::-;;;;;;;;;;;;;:::i;41827:334::-;;;;;;;;;;-1:-1:-1;41827:334:0;;;;;:::i;:::-;;:::i;43561:164::-;;;;;;;;;;-1:-1:-1;43561:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;43682:25:0;;;43658:4;43682:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;43561:164;8619:201;;;;;;;;;;-1:-1:-1;8619:201:0;;;;;:::i;:::-;;:::i;71065:99::-;;;;;;;;;;-1:-1:-1;71065:99:0;;;;;:::i;:::-;;:::i;70308:179::-;70419:4;70443:36;70467:11;70443:23;:36::i;:::-;70436:43;70308:179;-1:-1:-1;;70308:179:0:o;41483:100::-;41537:13;41570:5;41563:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41483:100;:::o;43042:221::-;43118:7;46385:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46385:16:0;43138:73;;;;-1:-1:-1;;;43138:73:0;;11344:2:1;43138:73:0;;;11326:21:1;11383:2;11363:18;;;11356:30;11422:34;11402:18;;;11395:62;-1:-1:-1;;;11473:18:1;;;11466:42;11525:19;;43138:73:0;;;;;;;;;-1:-1:-1;43231:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;43231:24:0;;43042:221::o;42565:411::-;42646:13;42662:23;42677:7;42662:14;:23::i;:::-;42646:39;;42710:5;-1:-1:-1;;;;;42704:11:0;:2;-1:-1:-1;;;;;42704:11:0;;;42696:57;;;;-1:-1:-1;;;42696:57:0;;12944:2:1;42696:57:0;;;12926:21:1;12983:2;12963:18;;;12956:30;13022:34;13002:18;;;12995:62;-1:-1:-1;;;13073:18:1;;;13066:31;13114:19;;42696:57:0;12742:397:1;42696:57:0;6514:10;-1:-1:-1;;;;;42788:21:0;;;;:62;;-1:-1:-1;42813:37:0;42830:5;6514:10;43561:164;:::i;42813:37::-;42766:168;;;;-1:-1:-1;;;42766:168:0;;9397:2:1;42766:168:0;;;9379:21:1;9436:2;9416:18;;;9409:30;9475:34;9455:18;;;9448:62;9546:26;9526:18;;;9519:54;9590:19;;42766:168:0;9195:420:1;42766:168:0;42947:21;42956:2;42960:7;42947:8;:21::i;:::-;42635:341;42565:411;;:::o;43792:339::-;43987:41;6514:10;44020:7;43987:18;:41::i;:::-;43979:103;;;;-1:-1:-1;;;43979:103:0;;;;;;;:::i;:::-;44095:28;44105:4;44111:2;44115:7;44095:9;:28::i;70851:107::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;70923:16:::1;:27:::0;;;::::1;;-1:-1:-1::0;;;70923:27:0::1;-1:-1:-1::0;;;;70923:27:0;;::::1;::::0;;;::::1;::::0;;70851:107::o;54297:256::-;54394:7;54430:23;54447:5;54430:16;:23::i;:::-;54422:5;:31;54414:87;;;;-1:-1:-1;;;54414:87:0;;6630:2:1;54414:87:0;;;6612:21:1;6669:2;6649:18;;;6642:30;6708:34;6688:18;;;6681:62;-1:-1:-1;;;6759:18:1;;;6752:41;6810:19;;54414:87:0;6428:407:1;54414:87:0;-1:-1:-1;;;;;;54519:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;54297:256::o;71172:140::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;71267:37:::1;::::0;71235:21:::1;::::0;71275:10:::1;::::0;71267:37;::::1;;;::::0;71235:21;;71220:12:::1;71267:37:::0;71220:12;71267:37;71235:21;71275:10;71267:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;71209:103;71172:140::o:0;44202:185::-;44340:39;44357:4;44363:2;44367:7;44340:39;;;;;;;;;;;;:16;:39::i;54819:233::-;54894:7;54930:30;54717:10;:17;;54629:113;54930:30;54922:5;:38;54914:95;;;;-1:-1:-1;;;54914:95:0;;14451:2:1;54914:95:0;;;14433:21:1;14490:2;14470:18;;;14463:30;14529:34;14509:18;;;14502:62;-1:-1:-1;;;14580:18:1;;;14573:42;14632:19;;54914:95:0;14249:408:1;54914:95:0;55027:10;55038:5;55027:17;;;;;;;;:::i;:::-;;;;;;;;;55020:24;;54819:233;;;:::o;70495:109::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;70569:27;;::::1;::::0;:16:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;41177:239::-:0;41249:7;41285:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41285:16:0;41320:19;41312:73;;;;-1:-1:-1;;;41312:73:0;;10233:2:1;41312:73:0;;;10215:21:1;10272:2;10252:18;;;10245:30;10311:34;10291:18;;;10284:62;-1:-1:-1;;;10362:18:1;;;10355:39;10411:19;;41312:73:0;10031:405:1;69219:526:0;69281:10;69294:13;54717:10;:17;;54629:113;69294:13;69326:16;;69281:26;;-1:-1:-1;;;;69326:16:0;;;;69318:44;;;;-1:-1:-1;;;69318:44:0;;13346:2:1;69318:44:0;;;13328:21:1;13385:2;13365:18;;;13358:30;-1:-1:-1;;;13404:18:1;;;13397:45;13459:18;;69318:44:0;13144:339:1;69318:44:0;69058:2;69381:33;;;;;69373:63;;;;-1:-1:-1;;;69373:63:0;;14864:2:1;69373:63:0;;;14846:21:1;14903:2;14883:18;;;14876:30;-1:-1:-1;;;14922:18:1;;;14915:47;14979:18;;69373:63:0;14662:341:1;69373:63:0;69007:4;69455:19;;;;:2;:19;:::i;:::-;:33;;69447:60;;;;-1:-1:-1;;;69447:60:0;;13690:2:1;69447:60:0;;;13672:21:1;13729:2;13709:18;;;13702:30;-1:-1:-1;;;13748:18:1;;;13741:44;13802:18;;69447:60:0;13488:338:1;69447:60:0;69557:9;69539:14;69526:27;;:10;;:27;;;;:::i;:::-;:40;;69518:64;;;;-1:-1:-1;;;69518:64:0;;10643:2:1;69518:64:0;;;10625:21:1;10682:2;10662:18;;;10655:30;-1:-1:-1;;;10701:18:1;;;10694:41;10752:18;;69518:64:0;10441:335:1;69518:64:0;69656:1;69641:97;69664:14;69659:19;;:1;:19;;;69641:97;;69700:25;69706:10;69718:6;;;;:2;:6;:::i;:::-;69700:5;:25::i;:::-;69680:3;;;;:::i;:::-;;;;69641:97;;40907:208;40979:7;-1:-1:-1;;;;;41007:19:0;;40999:74;;;;-1:-1:-1;;;40999:74:0;;9822:2:1;40999:74:0;;;9804:21:1;9861:2;9841:18;;;9834:30;9900:34;9880:18;;;9873:62;-1:-1:-1;;;9951:18:1;;;9944:40;10001:19;;40999:74:0;9620:406:1;40999:74:0;-1:-1:-1;;;;;;41091:16:0;;;;;:9;:16;;;;;;;40907:208::o;8361:103::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;8426:30:::1;8453:1;8426:18;:30::i;:::-;8361:103::o:0;41652:104::-;41708:13;41741:7;41734:14;;;;;:::i;43335:155::-;43430:52;6514:10;43463:8;43473;43430:18;:52::i;44458:328::-;44633:41;6514:10;44666:7;44633:18;:41::i;:::-;44625:103;;;;-1:-1:-1;;;44625:103:0;;;;;;;:::i;:::-;44739:39;44753:4;44759:2;44763:7;44772:5;44739:13;:39::i;:::-;44458:328;;;;:::o;68892:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;41827:334::-;46361:4;46385:16;;;:7;:16;;;;;;41900:13;;-1:-1:-1;;;;;46385:16:0;41926:76;;;;-1:-1:-1;;;41926:76:0;;12528:2:1;41926:76:0;;;12510:21:1;12567:2;12547:18;;;12540:30;12606:34;12586:18;;;12579:62;-1:-1:-1;;;12657:18:1;;;12650:45;12712:19;;41926:76:0;12326:411:1;41926:76:0;42015:21;42039:10;:8;:10::i;:::-;42015:34;;42091:1;42073:7;42067:21;:25;:86;;;;;;;;;;;;;;;;;42119:7;42128:18;:7;:16;:18::i;:::-;42102:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42067:86;42060:93;41827:334;-1:-1:-1;;;41827:334:0:o;8619:201::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;8708:22:0;::::1;8700:73;;;::::0;-1:-1:-1;;;8700:73:0;;7461:2:1;8700:73:0::1;::::0;::::1;7443:21:1::0;7500:2;7480:18;;;7473:30;7539:34;7519:18;;;7512:62;-1:-1:-1;;;7590:18:1;;;7583:36;7636:19;;8700:73:0::1;7259:402:1::0;8700:73:0::1;8784:28;8803:8;8784:18;:28::i;:::-;8619:201:::0;:::o;71065:99::-;7783:6;;-1:-1:-1;;;;;7783:6:0;6514:10;7930:23;7922:68;;;;-1:-1:-1;;;7922:68:0;;;;;;;:::i;:::-;71135:10:::1;:21:::0;71065:99::o;55665:589::-;-1:-1:-1;;;;;55871:18:0;;55867:187;;55906:40;55938:7;57081:10;:17;;57054:24;;;;:15;:24;;;;;:44;;;57109:24;;;;;;;;;;;;56977:164;55906:40;55867:187;;;55976:2;-1:-1:-1;;;;;55968:10:0;:4;-1:-1:-1;;;;;55968:10:0;;55964:90;;55995:47;56028:4;56034:7;55995:32;:47::i;:::-;-1:-1:-1;;;;;56068:16:0;;56064:183;;56101:45;56138:7;56101:36;:45::i;56064:183::-;56174:4;-1:-1:-1;;;;;56168:10:0;:2;-1:-1:-1;;;;;56168:10:0;;56164:83;;56195:40;56223:2;56227:7;56195:27;:40::i;53989:224::-;54091:4;-1:-1:-1;;;;;;54115:50:0;;-1:-1:-1;;;54115:50:0;;:90;;;54169:36;54193:11;54169:23;:36::i;50278:174::-;50353:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;50353:29:0;-1:-1:-1;;;;;50353:29:0;;;;;;;;:24;;50407:23;50353:24;50407:14;:23::i;:::-;-1:-1:-1;;;;;50398:46:0;;;;;;;;;;;50278:174;;:::o;46590:348::-;46683:4;46385:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46385:16:0;46700:73;;;;-1:-1:-1;;;46700:73:0;;8984:2:1;46700:73:0;;;8966:21:1;9023:2;9003:18;;;8996:30;9062:34;9042:18;;;9035:62;-1:-1:-1;;;9113:18:1;;;9106:42;9165:19;;46700:73:0;8782:408:1;46700:73:0;46784:13;46800:23;46815:7;46800:14;:23::i;:::-;46784:39;;46853:5;-1:-1:-1;;;;;46842:16:0;:7;-1:-1:-1;;;;;46842:16:0;;:51;;;;46886:7;-1:-1:-1;;;;;46862:31:0;:20;46874:7;46862:11;:20::i;:::-;-1:-1:-1;;;;;46862:31:0;;46842:51;:87;;;-1:-1:-1;;;;;;43682:25:0;;;43658:4;43682:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;46897:32;46834:96;46590:348;-1:-1:-1;;;;46590:348:0:o;49582:578::-;49741:4;-1:-1:-1;;;;;49714:31:0;:23;49729:7;49714:14;:23::i;:::-;-1:-1:-1;;;;;49714:31:0;;49706:85;;;;-1:-1:-1;;;49706:85:0;;12118:2:1;49706:85:0;;;12100:21:1;12157:2;12137:18;;;12130:30;12196:34;12176:18;;;12169:62;-1:-1:-1;;;12247:18:1;;;12240:39;12296:19;;49706:85:0;11916:405:1;49706:85:0;-1:-1:-1;;;;;49810:16:0;;49802:65;;;;-1:-1:-1;;;49802:65:0;;8225:2:1;49802:65:0;;;8207:21:1;8264:2;8244:18;;;8237:30;8303:34;8283:18;;;8276:62;-1:-1:-1;;;8354:18:1;;;8347:34;8398:19;;49802:65:0;8023:400:1;49802:65:0;49880:39;49901:4;49907:2;49911:7;49880:20;:39::i;:::-;49984:29;50001:1;50005:7;49984:8;:29::i;:::-;-1:-1:-1;;;;;50026:15:0;;;;;;:9;:15;;;;;:20;;50045:1;;50026:15;:20;;50045:1;;50026:20;:::i;:::-;;;;-1:-1:-1;;;;;;;50057:13:0;;;;;;:9;:13;;;;;:18;;50074:1;;50057:13;:18;;50074:1;;50057:18;:::i;:::-;;;;-1:-1:-1;;50086:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;50086:21:0;-1:-1:-1;;;;;50086:21:0;;;;;;;;;50125:27;;50086:16;;50125:27;;;;;;;49582:578;;;:::o;48274:382::-;-1:-1:-1;;;;;48354:16:0;;48346:61;;;;-1:-1:-1;;;48346:61:0;;10983:2:1;48346:61:0;;;10965:21:1;;;11002:18;;;10995:30;11061:34;11041:18;;;11034:62;11113:18;;48346:61:0;10781:356:1;48346:61:0;46361:4;46385:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46385:16:0;:30;48418:58;;;;-1:-1:-1;;;48418:58:0;;7868:2:1;48418:58:0;;;7850:21:1;7907:2;7887:18;;;7880:30;7946;7926:18;;;7919:58;7994:18;;48418:58:0;7666:352:1;48418:58:0;48489:45;48518:1;48522:2;48526:7;48489:20;:45::i;:::-;-1:-1:-1;;;;;48547:13:0;;;;;;:9;:13;;;;;:18;;48564:1;;48547:13;:18;;48564:1;;48547:18;:::i;:::-;;;;-1:-1:-1;;48576:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;48576:21:0;-1:-1:-1;;;;;48576:21:0;;;;;;;;48615:33;;48576:16;;;48615:33;;48576:16;;48615:33;48274:382;;:::o;8980:191::-;9073:6;;;-1:-1:-1;;;;;9090:17:0;;;-1:-1:-1;;;;;;9090:17:0;;;;;;;9123:40;;9073:6;;;9090:17;9073:6;;9123:40;;9054:16;;9123:40;9043:128;8980:191;:::o;50594:315::-;50749:8;-1:-1:-1;;;;;50740:17:0;:5;-1:-1:-1;;;;;50740:17:0;;;50732:55;;;;-1:-1:-1;;;50732:55:0;;8630:2:1;50732:55:0;;;8612:21:1;8669:2;8649:18;;;8642:30;8708:27;8688:18;;;8681:55;8753:18;;50732:55:0;8428:349:1;50732:55:0;-1:-1:-1;;;;;50798:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;50798:46:0;;;;;;;;;;50860:41;;6152::1;;;50860::0;;6125:18:1;50860:41:0;;;;;;;50594:315;;;:::o;45668:::-;45825:28;45835:4;45841:2;45845:7;45825:9;:28::i;:::-;45872:48;45895:4;45901:2;45905:7;45914:5;45872:22;:48::i;:::-;45864:111;;;;-1:-1:-1;;;45864:111:0;;;;;;;:::i;70612:117::-;70672:13;70705:16;70698:23;;;;;:::i;3996:723::-;4052:13;4273:10;4269:53;;-1:-1:-1;;4300:10:0;;;;;;;;;;;;-1:-1:-1;;;4300:10:0;;;;;3996:723::o;4269:53::-;4347:5;4332:12;4388:78;4395:9;;4388:78;;4421:8;;;;:::i;:::-;;-1:-1:-1;4444:10:0;;-1:-1:-1;4452:2:0;4444:10;;:::i;:::-;;;4388:78;;;4476:19;4508:6;4498:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4498:17:0;;4476:39;;4526:154;4533:10;;4526:154;;4560:11;4570:1;4560:11;;:::i;:::-;;-1:-1:-1;4629:10:0;4637:2;4629:5;:10;:::i;:::-;4616:24;;:2;:24;:::i;:::-;4603:39;;4586:6;4593;4586:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;4586:56:0;;;;;;;;-1:-1:-1;4657:11:0;4666:2;4657:11;;:::i;:::-;;;4526:154;;57768:988;58034:22;58084:1;58059:22;58076:4;58059:16;:22::i;:::-;:26;;;;:::i;:::-;58096:18;58117:26;;;:17;:26;;;;;;58034:51;;-1:-1:-1;58250:28:0;;;58246:328;;-1:-1:-1;;;;;58317:18:0;;58295:19;58317:18;;;:12;:18;;;;;;;;:34;;;;;;;;;58368:30;;;;;;:44;;;58485:30;;:17;:30;;;;;:43;;;58246:328;-1:-1:-1;58670:26:0;;;;:17;:26;;;;;;;;58663:33;;;-1:-1:-1;;;;;58714:18:0;;;;;:12;:18;;;;;:34;;;;;;;58707:41;57768:988::o;59051:1079::-;59329:10;:17;59304:22;;59329:21;;59349:1;;59329:21;:::i;:::-;59361:18;59382:24;;;:15;:24;;;;;;59755:10;:26;;59304:46;;-1:-1:-1;59382:24:0;;59304:46;;59755:26;;;;;;:::i;:::-;;;;;;;;;59733:48;;59819:11;59794:10;59805;59794:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;59899:28;;;:15;:28;;;;;;;:41;;;60071:24;;;;;60064:31;60106:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;59122:1008;;;59051:1079;:::o;56555:221::-;56640:14;56657:20;56674:2;56657:16;:20::i;:::-;-1:-1:-1;;;;;56688:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;56733:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;56555:221:0:o;40538:305::-;40640:4;-1:-1:-1;;;;;;40677:40:0;;-1:-1:-1;;;40677:40:0;;:105;;-1:-1:-1;;;;;;;40734:48:0;;-1:-1:-1;;;40734:48:0;40677:105;:158;;;-1:-1:-1;;;;;;;;;;32343:40:0;;;40799:36;32234:157;70119:181;70247:45;70274:4;70280:2;70284:7;70247:26;:45::i;51474:799::-;51629:4;-1:-1:-1;;;;;51650:13:0;;22413:20;22461:8;51646:620;;51686:72;;-1:-1:-1;;;51686:72:0;;-1:-1:-1;;;;;51686:36:0;;;;;:72;;6514:10;;51737:4;;51743:7;;51752:5;;51686:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51686:72:0;;;;;;;;-1:-1:-1;;51686:72:0;;;;;;;;;;;;:::i;:::-;;;51682:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51928:13:0;;51924:272;;51971:60;;-1:-1:-1;;;51971:60:0;;;;;;;:::i;51924:272::-;52146:6;52140:13;52131:6;52127:2;52123:15;52116:38;51682:529;-1:-1:-1;;;;;;51809:51:0;-1:-1:-1;;;51809:51:0;;-1:-1:-1;51802:58:0;;51646:620;-1:-1:-1;52250:4:0;51474:799;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;747:70;650:173;;;:::o;828:160::-;893:20;;949:13;;942:21;932:32;;922:60;;978:1;975;968:12;993:186;1052:6;1105:2;1093:9;1084:7;1080:23;1076:32;1073:52;;;1121:1;1118;1111:12;1073:52;1144:29;1163:9;1144:29;:::i;1184:260::-;1252:6;1260;1313:2;1301:9;1292:7;1288:23;1284:32;1281:52;;;1329:1;1326;1319:12;1281:52;1352:29;1371:9;1352:29;:::i;:::-;1342:39;;1400:38;1434:2;1423:9;1419:18;1400:38;:::i;:::-;1390:48;;1184:260;;;;;:::o;1449:328::-;1526:6;1534;1542;1595:2;1583:9;1574:7;1570:23;1566:32;1563:52;;;1611:1;1608;1601:12;1563:52;1634:29;1653:9;1634:29;:::i;:::-;1624:39;;1682:38;1716:2;1705:9;1701:18;1682:38;:::i;:::-;1672:48;;1767:2;1756:9;1752:18;1739:32;1729:42;;1449:328;;;;;:::o;1782:666::-;1877:6;1885;1893;1901;1954:3;1942:9;1933:7;1929:23;1925:33;1922:53;;;1971:1;1968;1961:12;1922:53;1994:29;2013:9;1994:29;:::i;:::-;1984:39;;2042:38;2076:2;2065:9;2061:18;2042:38;:::i;:::-;2032:48;;2127:2;2116:9;2112:18;2099:32;2089:42;;2182:2;2171:9;2167:18;2154:32;2209:18;2201:6;2198:30;2195:50;;;2241:1;2238;2231:12;2195:50;2264:22;;2317:4;2309:13;;2305:27;-1:-1:-1;2295:55:1;;2346:1;2343;2336:12;2295:55;2369:73;2434:7;2429:2;2416:16;2411:2;2407;2403:11;2369:73;:::i;:::-;2359:83;;;1782:666;;;;;;;:::o;2453:254::-;2518:6;2526;2579:2;2567:9;2558:7;2554:23;2550:32;2547:52;;;2595:1;2592;2585:12;2547:52;2618:29;2637:9;2618:29;:::i;:::-;2608:39;;2666:35;2697:2;2686:9;2682:18;2666:35;:::i;2712:254::-;2780:6;2788;2841:2;2829:9;2820:7;2816:23;2812:32;2809:52;;;2857:1;2854;2847:12;2809:52;2880:29;2899:9;2880:29;:::i;:::-;2870:39;2956:2;2941:18;;;;2928:32;;-1:-1:-1;;;2712:254:1:o;2971:180::-;3027:6;3080:2;3068:9;3059:7;3055:23;3051:32;3048:52;;;3096:1;3093;3086:12;3048:52;3119:26;3135:9;3119:26;:::i;3156:245::-;3214:6;3267:2;3255:9;3246:7;3242:23;3238:32;3235:52;;;3283:1;3280;3273:12;3235:52;3322:9;3309:23;3341:30;3365:5;3341:30;:::i;3406:249::-;3475:6;3528:2;3516:9;3507:7;3503:23;3499:32;3496:52;;;3544:1;3541;3534:12;3496:52;3576:9;3570:16;3595:30;3619:5;3595:30;:::i;3660:450::-;3729:6;3782:2;3770:9;3761:7;3757:23;3753:32;3750:52;;;3798:1;3795;3788:12;3750:52;3838:9;3825:23;3871:18;3863:6;3860:30;3857:50;;;3903:1;3900;3893:12;3857:50;3926:22;;3979:4;3971:13;;3967:27;-1:-1:-1;3957:55:1;;4008:1;4005;3998:12;3957:55;4031:73;4096:7;4091:2;4078:16;4073:2;4069;4065:11;4031:73;:::i;4115:180::-;4174:6;4227:2;4215:9;4206:7;4202:23;4198:32;4195:52;;;4243:1;4240;4233:12;4195:52;-1:-1:-1;4266:23:1;;4115:180;-1:-1:-1;4115:180:1:o;4300:269::-;4357:6;4410:2;4398:9;4389:7;4385:23;4381:32;4378:52;;;4426:1;4423;4416:12;4378:52;4465:9;4452:23;4515:4;4508:5;4504:16;4497:5;4494:27;4484:55;;4535:1;4532;4525:12;4574:257;4615:3;4653:5;4647:12;4680:6;4675:3;4668:19;4696:63;4752:6;4745:4;4740:3;4736:14;4729:4;4722:5;4718:16;4696:63;:::i;:::-;4813:2;4792:15;-1:-1:-1;;4788:29:1;4779:39;;;;4820:4;4775:50;;4574:257;-1:-1:-1;;4574:257:1:o;4836:470::-;5015:3;5053:6;5047:13;5069:53;5115:6;5110:3;5103:4;5095:6;5091:17;5069:53;:::i;:::-;5185:13;;5144:16;;;;5207:57;5185:13;5144:16;5241:4;5229:17;;5207:57;:::i;:::-;5280:20;;4836:470;-1:-1:-1;;;;4836:470:1:o;5519:488::-;-1:-1:-1;;;;;5788:15:1;;;5770:34;;5840:15;;5835:2;5820:18;;5813:43;5887:2;5872:18;;5865:34;;;5935:3;5930:2;5915:18;;5908:31;;;5713:4;;5956:45;;5981:19;;5973:6;5956:45;:::i;:::-;5948:53;5519:488;-1:-1:-1;;;;;;5519:488:1:o;6204:219::-;6353:2;6342:9;6335:21;6316:4;6373:44;6413:2;6402:9;6398:18;6390:6;6373:44;:::i;6840:414::-;7042:2;7024:21;;;7081:2;7061:18;;;7054:30;7120:34;7115:2;7100:18;;7093:62;-1:-1:-1;;;7186:2:1;7171:18;;7164:48;7244:3;7229:19;;6840:414::o;11555:356::-;11757:2;11739:21;;;11776:18;;;11769:30;11835:34;11830:2;11815:18;;11808:62;11902:2;11887:18;;11555:356::o;13831:413::-;14033:2;14015:21;;;14072:2;14052:18;;;14045:30;14111:34;14106:2;14091:18;;14084:62;-1:-1:-1;;;14177:2:1;14162:18;;14155:47;14234:3;14219:19;;13831:413::o;15379:128::-;15419:3;15450:1;15446:6;15443:1;15440:13;15437:39;;;15456:18;;:::i;:::-;-1:-1:-1;15492:9:1;;15379:128::o;15512:120::-;15552:1;15578;15568:35;;15583:18;;:::i;:::-;-1:-1:-1;15617:9:1;;15512:120::o;15637:168::-;15677:7;15743:1;15739;15735:6;15731:14;15728:1;15725:21;15720:1;15713:9;15706:17;15702:45;15699:71;;;15750:18;;:::i;:::-;-1:-1:-1;15790:9:1;;15637:168::o;15810:125::-;15850:4;15878:1;15875;15872:8;15869:34;;;15883:18;;:::i;:::-;-1:-1:-1;15920:9:1;;15810:125::o;15940:258::-;16012:1;16022:113;16036:6;16033:1;16030:13;16022:113;;;16112:11;;;16106:18;16093:11;;;16086:39;16058:2;16051:10;16022:113;;;16153:6;16150:1;16147:13;16144:48;;;-1:-1:-1;;16188:1:1;16170:16;;16163:27;15940:258::o;16203:380::-;16282:1;16278:12;;;;16325;;;16346:61;;16400:4;16392:6;16388:17;16378:27;;16346:61;16453:2;16445:6;16442:14;16422:18;16419:38;16416:161;;;16499:10;16494:3;16490:20;16487:1;16480:31;16534:4;16531:1;16524:15;16562:4;16559:1;16552:15;16416:161;;16203:380;;;:::o;16588:135::-;16627:3;-1:-1:-1;;16648:17:1;;16645:43;;;16668:18;;:::i;:::-;-1:-1:-1;16715:1:1;16704:13;;16588:135::o;16728:175::-;16765:3;16809:4;16802:5;16798:16;16838:4;16829:7;16826:17;16823:43;;;16846:18;;:::i;:::-;16895:1;16882:15;;16728:175;-1:-1:-1;;16728:175:1:o;16908:112::-;16940:1;16966;16956:35;;16971:18;;:::i;:::-;-1:-1:-1;17005:9:1;;16908:112::o;17025:127::-;17086:10;17081:3;17077:20;17074:1;17067:31;17117:4;17114:1;17107:15;17141:4;17138:1;17131:15;17157:127;17218:10;17213:3;17209:20;17206:1;17199:31;17249:4;17246:1;17239:15;17273:4;17270:1;17263:15;17289:127;17350:10;17345:3;17341:20;17338:1;17331:31;17381:4;17378:1;17371:15;17405:4;17402:1;17395:15;17421:127;17482:10;17477:3;17473:20;17470:1;17463:31;17513:4;17510:1;17503:15;17537:4;17534:1;17527:15;17553:127;17614:10;17609:3;17605:20;17602:1;17595:31;17645:4;17642:1;17635:15;17669:4;17666:1;17659:15;17685:131;-1:-1:-1;;;;;;17759:32:1;;17749:43;;17739:71;;17806:1;17803;17796:12

Swarm Source

ipfs://25dda748559eec8e64dea5cce560c5d33034fdc0924ff706bb7dee32a030dc58

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