Token

Reflektor (Reflektor)

ERC-721

Overview

Max Total Supply

1,829 Reflektor

Holders

904

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xeffb66c7b83fd47c7b35dc78cc68a28568b75f02

Filtered by Token Holder

0x824d4d5e1B635587F012BE3cb5EEFb8B2e416624

kaifarik.eth

Balance

2 Reflektor

0x824d4d5e1b635587f012be3cb5eefb8b2e416624

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Reflektor

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 2022-10-31
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;



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

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





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

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

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

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

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

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

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

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



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





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

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

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

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

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

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

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

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

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

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

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

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



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





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

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

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



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



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

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

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

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

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





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











/**
 * @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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //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 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 {}
}



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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}



/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}



/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}



/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}


interface RE {
    function changeReservedFromWallet(address wallet, uint256 amount) external;
    function reservedBots(address) external returns(uint256);
}

contract Reflektor is ERC721, Ownable {
    RE public reservation;

    using ECDSA for bytes32;
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    Counters.Counter private Bots;
    string private baseURI;

    uint256 constant public maxBots = 5555;
    uint256 public publicBotsMinted = 0;

    uint256 public maxReserved = 1550;
    uint256 public maxPhaseOneSupply = 3000;
    uint256 public mintPrice = 0.2 ether;
    uint256 public currentPhase = 0;
    uint256 public maxPerTxn = 5;
    address public merkleAddress;
    bool public waveEnabled = false;

    mapping(uint256 => bool) public usedTokens;
    mapping(string => bool) public usedNonces;

    event Minted(address minter, uint256 amount, uint256 timestamp);
    event Claimed(address minter, uint256 amount, uint256 timestamp);
    event WhitelistMint(address minter, uint256 amount, uint256 timestamp);

    // if you know, you know
    modifier agentOfChaosBlocker() {
        require(tx.origin == msg.sender, "This isn't the super market");
        _;
    }

    constructor() ERC721("Reflektor", "Reflektor") {}

    // reserves token for the deployer
    function reserve(uint256 qty) public payable onlyOwner {
        uint256 currentBots = Bots.current();

        for (uint256 i; i < qty; i++) {
            _safeMint(msg.sender, currentBots + i);
            Bots.increment();
        }

        emit Minted(msg.sender, qty, block.timestamp);
    }

    // phase 1 mint for mirror holders & any collabs
    function phaseOneMint(string calldata nonce, uint256 qty, bytes calldata proof) public payable agentOfChaosBlocker {
        uint256 currentBots = Bots.current();

        require(currentPhase == 1, "Whitelist mint is not ready yet!");
        require(currentBots <= maxPhaseOneSupply, "Max Supply for Phase One reached!");
        require(!usedNonces[nonce], "Invalid Proof");
        require(mintPrice * qty == msg.value, "Invalid ETH Provided");
        require(qty >= 1 && qty <= maxPerTxn, "Invalid Quantity");
        require(isValidSignature(keccak256(abi.encodePacked(msg.sender, qty, nonce)), proof), "Invalid Proof Signature");

        usedNonces[nonce] = true;

        for (uint256 i; i < qty; i++) {
            _safeMint(msg.sender, currentBots + i);
            Bots.increment();
        }

        emit WhitelistMint(msg.sender, qty, block.timestamp);
        publicBotsMinted += qty;
    }

    // phase 2 mint is public remaining supply that isn't reserved
    function phaseTwoMint(uint256 qty) public payable agentOfChaosBlocker {
        uint256 currentBots = Bots.current();

        require(currentPhase == 2, "Public Mint is not ready yet!");
        require(currentBots + maxReserved <= maxBots, "Max Supply for Phase Two reached!");
        require(mintPrice * qty == msg.value, "Invalid ETH Provided");
        require(qty >= 1 && qty <= maxPerTxn, "Invalid Quantity");

        for (uint256 i; i < qty; i++) {
            _safeMint(msg.sender, currentBots + i);
            Bots.increment();
        }

        emit Minted(msg.sender, qty, block.timestamp);
        publicBotsMinted += qty;
    }

    // phase 3 mint is the reservation claim
    function phaseThreeMint(uint256 qty) public payable agentOfChaosBlocker {
        uint256 currentBots = Bots.current();
        uint256 reserved = reservation.reservedBots(msg.sender);

        require(currentPhase == 3, "Reservation Claim is not ready yet!");
        require(reserved > 0, "You don't have anymore claims left!");
        require(reserved >= qty, "You are attempting to claim more then you have reserved!");
        require(msg.value == 0, "No ETH required for claim");
        require(qty >= 1 && qty <= maxPerTxn, "Invalid Quantity");

        reservation.changeReservedFromWallet(msg.sender, reserved - qty);

        for (uint256 i; i < qty; i++) {
            _safeMint(msg.sender, currentBots + i);
            Bots.increment();
        }

        emit Claimed(msg.sender, qty, block.timestamp);
    }

    // if for some reason we don't mint out, this allows us to reenable public at a later time
    function releaseWave(uint256 qty) public payable agentOfChaosBlocker {
        uint256 currentBots = Bots.current();

        require(waveEnabled, "Waves aren't enabled yet!");
        require(publicBotsMinted + maxReserved <= maxBots, "Max Supply has been reached!");
        require(mintPrice * qty == msg.value, "Invalid ETH Provided");
        require(qty >= 1 && qty <= maxPerTxn, "Invalid Quantity");

        for (uint256 i; i < qty; i++) {
            _safeMint(msg.sender, currentBots + i);
            Bots.increment();
        }

        emit Minted(msg.sender, qty, block.timestamp);
        publicBotsMinted += qty;

    }

    // updates the max supply for phase 1
    function setMaxPhaseMint(uint256 max) public payable onlyOwner {
        maxPhaseOneSupply = max;
    }

    // sets the max mints per transaction
    function setMaxPer(uint256 max) public payable onlyOwner {
        maxPerTxn = max;
    }

    // updates the phase of our mint
    function setPhase(uint256 phase) public payable onlyOwner {
        currentPhase = phase;
    }
    
    // updates the mint price
    function setMintPrice(uint256 howMuch) public payable onlyOwner {
        mintPrice = howMuch;
    }

    // updates the metadata base uri to the new one, used for revealing
    function setMetadata(string memory metadata) public payable onlyOwner {
        baseURI = metadata;
    }

    // returns the total amount minted
    function totalSupply() external view returns(uint256) {
        return Bots.current();
    }

    // required for the metadata to be visible on OS
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    // withdraws the mint functions to the contract deployer
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    // interface helper functions
    function setInterfaces(address ReservationContract) public onlyOwner {
        reservation = RE(ReservationContract);
    }

    // validates the merkle proof signature
    function isValidSignature(bytes32 hash, bytes calldata sig) internal view returns (bool) {
        bytes32 signed = hash.toEthSignedMessageHash();
        
        return merkleAddress == signed.recover(sig);
    }

    // sets the proof sig address
    function setValidator(address validator) public onlyOwner {
        merkleAddress = validator;
    }

    // sets the public release system
    function setWave(bool newWave) public onlyOwner {
        waveEnabled = newWave;
    }
    
    // helper functions required in order to transfer tokens
    function transferFrom(address from, address to, uint256 tokenId) public override {
        ERC721.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public override {
        safeTransferFrom(from, to, tokenId, "");
    }

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Minted","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"WhitelistMint","type":"event"},{"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":"currentPhase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"maxBots","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTxn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPhaseOneSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxReserved","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"nonce","type":"string"},{"internalType":"uint256","name":"qty","type":"uint256"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"phaseOneMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"phaseThreeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"phaseTwoMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicBotsMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"releaseWave","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservation","outputs":[{"internalType":"contract RE","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"reserve","outputs":[],"stateMutability":"payable","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":"address","name":"ReservationContract","type":"address"}],"name":"setInterfaces","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"max","type":"uint256"}],"name":"setMaxPer","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"max","type":"uint256"}],"name":"setMaxPhaseMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"metadata","type":"string"}],"name":"setMetadata","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"howMuch","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"phase","type":"uint256"}],"name":"setPhase","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"setValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newWave","type":"bool"}],"name":"setWave","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"usedNonces","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"usedTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"waveEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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

0x60806040526004361061025c5760003560e01c806369edb52c11610144578063a49a1e7d116100b6578063da8292d91161007a578063da8292d914610668578063e346c12014610688578063e4f376f0146106a8578063e985e9c5146106e3578063f2fde38b1461072c578063f4a0a5281461074c57600080fd5b8063a49a1e7d146105e9578063a9898fd9146105fc578063b88d4fde14610612578063c0cd938e14610632578063c87b56dd1461064857600080fd5b80638b362de0116101085780638b362de01461054f5780638da5cb5b1461056257806395d89b411461058057806395e9e5151461059557806398b88886146105a8578063a22cb465146105c957600080fd5b806369edb52c146104de57806370a08231146104f1578063715018a614610511578063793ca24814610526578063819b25ba1461053c57600080fd5b80632a5c4675116101dd57806348a92461116101a157806348a924611461044f57806350158e7e1461046257806350d641b11461047557806352f1910d146104955780636352211e146104a85780636817c76c146104c857600080fd5b80632a5c4675146103d15780632cc82655146103f15780633cb51994146104045780633ccfd60b1461041a57806342842e0e1461042f57600080fd5b80630f7ee879116102245780630f7ee879146103365780631327d3d81461036657806318024e821461038657806318160ddd1461039c57806323b872dd146103b157600080fd5b806301ffc9a714610261578063055ad42e1461029657806306fdde03146102ba578063081812fc146102dc578063095ea7b314610314575b600080fd5b34801561026d57600080fd5b5061028161027c3660046128d1565b61075f565b60405190151581526020015b60405180910390f35b3480156102a257600080fd5b506102ac600e5481565b60405190815260200161028d565b3480156102c657600080fd5b506102cf6107b1565b60405161028d9190612afc565b3480156102e857600080fd5b506102fc6102f73660046129ce565b610843565b6040516001600160a01b03909116815260200161028d565b34801561032057600080fd5b5061033461032f36600461288c565b6108dd565b005b34801561034257600080fd5b506102816103513660046129ce565b60116020526000908152604090205460ff1681565b34801561037257600080fd5b5061033461038136600461275c565b6109f3565b34801561039257600080fd5b506102ac600c5481565b3480156103a857600080fd5b506102ac610a3f565b3480156103bd57600080fd5b506103346103cc3660046127aa565b610a4f565b3480156103dd57600080fd5b506007546102fc906001600160a01b031681565b6103346103ff3660046129ce565b610a5a565b34801561041057600080fd5b506102ac600f5481565b34801561042657600080fd5b50610334610a89565b34801561043b57600080fd5b5061033461044a3660046127aa565b610ae6565b61033461045d3660046129ce565b610b01565b6103346104703660046129ce565b610e56565b34801561048157600080fd5b506103346104903660046128b6565b611028565b6103346104a33660046129ce565b611070565b3480156104b457600080fd5b506102fc6104c33660046129ce565b61109f565b3480156104d457600080fd5b506102ac600d5481565b6103346104ec3660046129ce565b611116565b3480156104fd57600080fd5b506102ac61050c36600461275c565b611291565b34801561051d57600080fd5b50610334611318565b34801561053257600080fd5b506102ac600a5481565b61033461054a3660046129ce565b61134e565b61033461055d3660046129ce565b6113fe565b34801561056e57600080fd5b506006546001600160a01b03166102fc565b34801561058c57600080fd5b506102cf61142d565b6103346105a336600461290b565b61143c565b3480156105b457600080fd5b5060105461028190600160a01b900460ff1681565b3480156105d557600080fd5b506103346105e4366004612862565b61171d565b6103346105f7366004612985565b6117e2565b34801561060857600080fd5b506102ac600b5481565b34801561061e57600080fd5b5061033461062d3660046127e6565b61181f565b34801561063e57600080fd5b506102ac6115b381565b34801561065457600080fd5b506102cf6106633660046129ce565b611831565b34801561067457600080fd5b5061033461068336600461275c565b61190c565b34801561069457600080fd5b506010546102fc906001600160a01b031681565b3480156106b457600080fd5b506102816106c3366004612985565b805160208183018101805160128252928201919093012091525460ff1681565b3480156106ef57600080fd5b506102816106fe366004612777565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b34801561073857600080fd5b5061033461074736600461275c565b611958565b61033461075a3660046129ce565b6119f3565b60006001600160e01b031982166380ac58cd60e01b148061079057506001600160e01b03198216635b5e139f60e01b145b806107ab57506301ffc9a760e01b6001600160e01b03198316145b92915050565b6060600080546107c090612d04565b80601f01602080910402602001604051908101604052809291908181526020018280546107ec90612d04565b80156108395780601f1061080e57610100808354040283529160200191610839565b820191906000526020600020905b81548152906001019060200180831161081c57829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b03166108c15760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084015b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b60006108e88261109f565b9050806001600160a01b0316836001600160a01b031614156109565760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b60648201526084016108b8565b336001600160a01b0382161480610972575061097281336106fe565b6109e45760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c000000000000000060648201526084016108b8565b6109ee8383611a22565b505050565b6006546001600160a01b03163314610a1d5760405162461bcd60e51b81526004016108b890612bb9565b601080546001600160a01b0319166001600160a01b0392909216919091179055565b6000610a4a60085490565b905090565b6109ee838383611a90565b6006546001600160a01b03163314610a845760405162461bcd60e51b81526004016108b890612bb9565b600e55565b6006546001600160a01b03163314610ab35760405162461bcd60e51b81526004016108b890612bb9565b6040514790339082156108fc029083906000818181858888f19350505050158015610ae2573d6000803e3d6000fd5b5050565b6109ee8383836040518060200160405280600081525061181f565b323314610b205760405162461bcd60e51b81526004016108b890612c3f565b6000610b2b60085490565b60075460405163583bb8f760e11b81523360048201529192506000916001600160a01b039091169063b07771ee90602401602060405180830381600087803b158015610b7657600080fd5b505af1158015610b8a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bae91906129e7565b9050600e54600314610c0e5760405162461bcd60e51b815260206004820152602360248201527f5265736572766174696f6e20436c61696d206973206e6f74207265616479207960448201526265742160e81b60648201526084016108b8565b60008111610c6a5760405162461bcd60e51b815260206004820152602360248201527f596f7520646f6e2774206861766520616e796d6f726520636c61696d73206c6560448201526266742160e81b60648201526084016108b8565b82811015610ce05760405162461bcd60e51b815260206004820152603860248201527f596f752061726520617474656d7074696e6720746f20636c61696d206d6f726560448201527f207468656e20796f75206861766520726573657276656421000000000000000060648201526084016108b8565b3415610d2e5760405162461bcd60e51b815260206004820152601960248201527f4e6f2045544820726571756972656420666f7220636c61696d0000000000000060448201526064016108b8565b60018310158015610d415750600f548311155b610d5d5760405162461bcd60e51b81526004016108b890612b0f565b6007546001600160a01b031663abb80ad733610d798685612cc1565b6040516001600160e01b031960e085901b1681526001600160a01b0390921660048301526024820152604401600060405180830381600087803b158015610dbf57600080fd5b505af1158015610dd3573d6000803e3d6000fd5b5050505060005b83811015610e1557610df533610df08386612c76565b611ac1565b610e03600880546001019055565b80610e0d81612d3f565b915050610dda565b507f987d620f307ff6b94d58743cb7a7509f24071586a77759b77c2d4e29f75a2f9a338442604051610e4993929190612adb565b60405180910390a1505050565b323314610e755760405162461bcd60e51b81526004016108b890612c3f565b6000610e8060085490565b601054909150600160a01b900460ff16610edc5760405162461bcd60e51b815260206004820152601960248201527f5761766573206172656e277420656e61626c656420796574210000000000000060448201526064016108b8565b6115b3600b54600a54610eef9190612c76565b1115610f3d5760405162461bcd60e51b815260206004820152601c60248201527f4d617820537570706c7920686173206265656e2072656163686564210000000060448201526064016108b8565b3482600d54610f4c9190612ca2565b14610f695760405162461bcd60e51b81526004016108b890612b8b565b60018210158015610f7c5750600f548211155b610f985760405162461bcd60e51b81526004016108b890612b0f565b60005b82811015610fd157610fb133610df08385612c76565b610fbf600880546001019055565b80610fc981612d3f565b915050610f9b565b507f25b428dfde728ccfaddad7e29e4ac23c24ed7fd1a6e3e3f91894a9a073f5dfff33834260405161100593929190612adb565b60405180910390a181600a600082825461101f9190612c76565b90915550505050565b6006546001600160a01b031633146110525760405162461bcd60e51b81526004016108b890612bb9565b60108054911515600160a01b0260ff60a01b19909216919091179055565b6006546001600160a01b0316331461109a5760405162461bcd60e51b81526004016108b890612bb9565b600f55565b6000818152600260205260408120546001600160a01b0316806107ab5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b60648201526084016108b8565b3233146111355760405162461bcd60e51b81526004016108b890612c3f565b600061114060085490565b9050600e546002146111945760405162461bcd60e51b815260206004820152601d60248201527f5075626c6963204d696e74206973206e6f74207265616479207965742100000060448201526064016108b8565b6115b3600b54826111a59190612c76565b11156111fd5760405162461bcd60e51b815260206004820152602160248201527f4d617820537570706c7920666f722050686173652054776f20726561636865646044820152602160f81b60648201526084016108b8565b3482600d5461120c9190612ca2565b146112295760405162461bcd60e51b81526004016108b890612b8b565b6001821015801561123c5750600f548211155b6112585760405162461bcd60e51b81526004016108b890612b0f565b60005b82811015610fd15761127133610df08385612c76565b61127f600880546001019055565b8061128981612d3f565b91505061125b565b60006001600160a01b0382166112fc5760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b60648201526084016108b8565b506001600160a01b031660009081526003602052604090205490565b6006546001600160a01b031633146113425760405162461bcd60e51b81526004016108b890612bb9565b61134c6000611adb565b565b6006546001600160a01b031633146113785760405162461bcd60e51b81526004016108b890612bb9565b600061138360085490565b905060005b828110156113be5761139e33610df08385612c76565b6113ac600880546001019055565b806113b681612d3f565b915050611388565b507f25b428dfde728ccfaddad7e29e4ac23c24ed7fd1a6e3e3f91894a9a073f5dfff3383426040516113f293929190612adb565b60405180910390a15050565b6006546001600160a01b031633146114285760405162461bcd60e51b81526004016108b890612bb9565b600c55565b6060600180546107c090612d04565b32331461145b5760405162461bcd60e51b81526004016108b890612c3f565b600061146660085490565b9050600e546001146114ba5760405162461bcd60e51b815260206004820181905260248201527f57686974656c697374206d696e74206973206e6f74207265616479207965742160448201526064016108b8565b600c548111156115165760405162461bcd60e51b815260206004820152602160248201527f4d617820537570706c7920666f72205068617365204f6e6520726561636865646044820152602160f81b60648201526084016108b8565b60128686604051611528929190612a5f565b9081526040519081900360200190205460ff16156115785760405162461bcd60e51b815260206004820152600d60248201526c24b73b30b634b210283937b7b360991b60448201526064016108b8565b3484600d546115879190612ca2565b146115a45760405162461bcd60e51b81526004016108b890612b8b565b600184101580156115b75750600f548411155b6115d35760405162461bcd60e51b81526004016108b890612b0f565b61160a338588886040516020016115ed9493929190612a2c565b604051602081830303815290604052805190602001208484611b2d565b6116565760405162461bcd60e51b815260206004820152601760248201527f496e76616c69642050726f6f66205369676e617475726500000000000000000060448201526064016108b8565b60016012878760405161166a929190612a5f565b908152604051908190036020019020805491151560ff1990921691909117905560005b848110156116c3576116a333610df08385612c76565b6116b1600880546001019055565b806116bb81612d3f565b91505061168d565b507e5544be4178eb2f133876b00c929ab6b808950e7b7794c44cce47b63fbe567f3385426040516116f693929190612adb565b60405180910390a183600a60008282546117109190612c76565b9091555050505050505050565b6001600160a01b0382163314156117765760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c65720000000000000060448201526064016108b8565b3360008181526005602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6006546001600160a01b0316331461180c5760405162461bcd60e51b81526004016108b890612bb9565b8051610ae29060099060208401906125df565b61182b84848484611be5565b50505050565b6000818152600260205260409020546060906001600160a01b03166118b05760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084016108b8565b60006118ba611c17565b905060008151116118da5760405180602001604052806000815250611905565b806118e484611c26565b6040516020016118f5929190612a6f565b6040516020818303038152906040525b9392505050565b6006546001600160a01b031633146119365760405162461bcd60e51b81526004016108b890612bb9565b600780546001600160a01b0319166001600160a01b0392909216919091179055565b6006546001600160a01b031633146119825760405162461bcd60e51b81526004016108b890612bb9565b6001600160a01b0381166119e75760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016108b8565b6119f081611adb565b50565b6006546001600160a01b03163314611a1d5760405162461bcd60e51b81526004016108b890612bb9565b600d55565b600081815260046020526040902080546001600160a01b0319166001600160a01b0384169081179091558190611a578261109f565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b611a9a3382611d2c565b611ab65760405162461bcd60e51b81526004016108b890612bee565b6109ee838383611e1f565b610ae2828260405180602001604052806000815250611fbf565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600080611b87856040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b9050611bcb84848080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152508593925050611ff29050565b6010546001600160a01b0391821691161495945050505050565b611bef3383611d2c565b611c0b5760405162461bcd60e51b81526004016108b890612bee565b61182b84848484612016565b6060600980546107c090612d04565b606081611c4a5750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611c745780611c5e81612d3f565b9150611c6d9050600a83612c8e565b9150611c4e565b60008167ffffffffffffffff811115611c8f57611c8f612dc6565b6040519080825280601f01601f191660200182016040528015611cb9576020820181803683370190505b5090505b8415611d2457611cce600183612cc1565b9150611cdb600a86612d5a565b611ce6906030612c76565b60f81b818381518110611cfb57611cfb612db0565b60200101906001600160f81b031916908160001a905350611d1d600a86612c8e565b9450611cbd565b949350505050565b6000818152600260205260408120546001600160a01b0316611da55760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084016108b8565b6000611db08361109f565b9050806001600160a01b0316846001600160a01b03161480611deb5750836001600160a01b0316611de084610843565b6001600160a01b0316145b80611d2457506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff16611d24565b826001600160a01b0316611e328261109f565b6001600160a01b031614611e9a5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201526839903737ba1037bbb760b91b60648201526084016108b8565b6001600160a01b038216611efc5760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b60648201526084016108b8565b611f07600082611a22565b6001600160a01b0383166000908152600360205260408120805460019290611f30908490612cc1565b90915550506001600160a01b0382166000908152600360205260408120805460019290611f5e908490612c76565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b611fc98383612049565b611fd6600084848461218b565b6109ee5760405162461bcd60e51b81526004016108b890612b39565b60008060006120018585612298565b9150915061200e81612308565b509392505050565b612021848484611e1f565b61202d8484848461218b565b61182b5760405162461bcd60e51b81526004016108b890612b39565b6001600160a01b03821661209f5760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f206164647265737360448201526064016108b8565b6000818152600260205260409020546001600160a01b0316156121045760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016108b8565b6001600160a01b038216600090815260036020526040812080546001929061212d908490612c76565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b60006001600160a01b0384163b1561228d57604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906121cf903390899088908890600401612a9e565b602060405180830381600087803b1580156121e957600080fd5b505af1925050508015612219575060408051601f3d908101601f19168201909252612216918101906128ee565b60015b612273573d808015612247576040519150601f19603f3d011682016040523d82523d6000602084013e61224c565b606091505b50805161226b5760405162461bcd60e51b81526004016108b890612b39565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611d24565b506001949350505050565b6000808251604114156122cf5760208301516040840151606085015160001a6122c3878285856124c3565b94509450505050612301565b8251604014156122f957602083015160408401516122ee8683836125b0565b935093505050612301565b506000905060025b9250929050565b600081600481111561231c5761231c612d9a565b14156123255750565b600181600481111561233957612339612d9a565b14156123875760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016108b8565b600281600481111561239b5761239b612d9a565b14156123e95760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016108b8565b60038160048111156123fd576123fd612d9a565b14156124565760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b60648201526084016108b8565b600481600481111561246a5761246a612d9a565b14156119f05760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604482015261756560f01b60648201526084016108b8565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08311156124fa57506000905060036125a7565b8460ff16601b1415801561251257508460ff16601c14155b1561252357506000905060046125a7565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015612577573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166125a0576000600192509250506125a7565b9150600090505b94509492505050565b6000806001600160ff1b03831660ff84901c601b016125d1878288856124c3565b935093505050935093915050565b8280546125eb90612d04565b90600052602060002090601f01602090048101928261260d5760008555612653565b82601f1061262657805160ff1916838001178555612653565b82800160010185558215612653579182015b82811115612653578251825591602001919060010190612638565b5061265f929150612663565b5090565b5b8082111561265f5760008155600101612664565b600067ffffffffffffffff8084111561269357612693612dc6565b604051601f8501601f19908116603f011681019082821181831017156126bb576126bb612dc6565b816040528093508581528686860111156126d457600080fd5b858560208301376000602087830101525050509392505050565b80356001600160a01b038116811461270557600080fd5b919050565b8035801515811461270557600080fd5b60008083601f84011261272c57600080fd5b50813567ffffffffffffffff81111561274457600080fd5b60208301915083602082850101111561230157600080fd5b60006020828403121561276e57600080fd5b611905826126ee565b6000806040838503121561278a57600080fd5b612793836126ee565b91506127a1602084016126ee565b90509250929050565b6000806000606084860312156127bf57600080fd5b6127c8846126ee565b92506127d6602085016126ee565b9150604084013590509250925092565b600080600080608085870312156127fc57600080fd5b612805856126ee565b9350612813602086016126ee565b925060408501359150606085013567ffffffffffffffff81111561283657600080fd5b8501601f8101871361284757600080fd5b61285687823560208401612678565b91505092959194509250565b6000806040838503121561287557600080fd5b61287e836126ee565b91506127a16020840161270a565b6000806040838503121561289f57600080fd5b6128a8836126ee565b946020939093013593505050565b6000602082840312156128c857600080fd5b6119058261270a565b6000602082840312156128e357600080fd5b813561190581612ddc565b60006020828403121561290057600080fd5b815161190581612ddc565b60008060008060006060868803121561292357600080fd5b853567ffffffffffffffff8082111561293b57600080fd5b61294789838a0161271a565b909750955060208801359450604088013591508082111561296757600080fd5b506129748882890161271a565b969995985093965092949392505050565b60006020828403121561299757600080fd5b813567ffffffffffffffff8111156129ae57600080fd5b8201601f810184136129bf57600080fd5b611d2484823560208401612678565b6000602082840312156129e057600080fd5b5035919050565b6000602082840312156129f957600080fd5b5051919050565b60008151808452612a18816020860160208601612cd8565b601f01601f19169290920160200192915050565b6bffffffffffffffffffffffff198560601b16815283601482015281836034830137600091016034019081529392505050565b8183823760009101908152919050565b60008351612a81818460208801612cd8565b835190830190612a95818360208801612cd8565b01949350505050565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612ad190830184612a00565b9695505050505050565b6001600160a01b039390931683526020830191909152604082015260600190565b6020815260006119056020830184612a00565b60208082526010908201526f496e76616c6964205175616e7469747960801b604082015260600190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b602080825260149082015273125b9d985b1a590811551208141c9bdd9a59195960621b604082015260600190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252601b908201527f546869732069736e277420746865207375706572206d61726b65740000000000604082015260600190565b60008219821115612c8957612c89612d6e565b500190565b600082612c9d57612c9d612d84565b500490565b6000816000190483118215151615612cbc57612cbc612d6e565b500290565b600082821015612cd357612cd3612d6e565b500390565b60005b83811015612cf3578181015183820152602001612cdb565b8381111561182b5750506000910152565b600181811c90821680612d1857607f821691505b60208210811415612d3957634e487b7160e01b600052602260045260246000fd5b50919050565b6000600019821415612d5357612d53612d6e565b5060010190565b600082612d6957612d69612d84565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052602160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160e01b0319811681146119f057600080fdfea264697066735822122047f1f7106e00bbfc5aa259ab551f91e1f6b2b04562761a417817056f2b95b81a64736f6c63430008070033

Deployed Bytecode Sourcemap

53079:7462:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22101:305;;;;;;;;;;-1:-1:-1;22101:305:0;;;;;:::i;:::-;;:::i;:::-;;;8991:14:1;;8984:22;8966:41;;8954:2;8939:18;22101:305:0;;;;;;;;53578:31;;;;;;;;;;;;;;;;;;;23476:25:1;;;23464:2;23449:18;53578:31:0;23330:177:1;23046:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;24605:221::-;;;;;;;;;;-1:-1:-1;24605:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;7660:32:1;;;7642:51;;7630:2;7615:18;24605:221:0;7496:203:1;24128:411:0;;;;;;;;;;-1:-1:-1;24128:411:0;;;;;:::i;:::-;;:::i;:::-;;53726:42;;;;;;;;;;-1:-1:-1;53726:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;59759:102;;;;;;;;;;-1:-1:-1;59759:102:0;;;;;:::i;:::-;;:::i;53489:39::-;;;;;;;;;;;;;;;;58808:94;;;;;;;;;;;;;:::i;60070:138::-;;;;;;;;;;-1:-1:-1;60070:138:0;;;;;:::i;:::-;;:::i;53124:21::-;;;;;;;;;;-1:-1:-1;53124:21:0;;;;-1:-1:-1;;;;;53124:21:0;;;58330:97;;;;;;:::i;:::-;;:::i;53616:28::-;;;;;;;;;;;;;;;;59134:143;;;;;;;;;;;;;:::i;60216:::-;;;;;;;;;;-1:-1:-1;60216:143:0;;;;;:::i;:::-;;:::i;56389:842::-;;;;;;:::i;:::-;;:::i;57335:651::-;;;;;;:::i;:::-;;:::i;59908:88::-;;;;;;;;;;-1:-1:-1;59908:88:0;;;;;:::i;:::-;;:::i;58193:91::-;;;;;;:::i;:::-;;:::i;22740:239::-;;;;;;;;;;-1:-1:-1;22740:239:0;;;;;:::i;:::-;;:::i;53535:36::-;;;;;;;;;;;;;;;;55675:660;;;;;;:::i;:::-;;:::i;22470:208::-;;;;;;;;;;-1:-1:-1;22470:208:0;;;;;:::i;:::-;;:::i;2387:94::-;;;;;;;;;;;;;:::i;53405:35::-;;;;;;;;;;;;;;;;54305:306;;;;;;:::i;:::-;;:::i;58037:105::-;;;;;;:::i;:::-;;:::i;1736:87::-;;;;;;;;;;-1:-1:-1;1809:6:0;;-1:-1:-1;;;;;1809:6:0;1736:87;;23215:104;;;;;;;;;;;;;:::i;54673:926::-;;;;;;:::i;:::-;;:::i;53686:31::-;;;;;;;;;;-1:-1:-1;53686:31:0;;;;-1:-1:-1;;;53686:31:0;;;;;;24898:295;;;;;;;;;;-1:-1:-1;24898:295:0;;;;;:::i;:::-;;:::i;58653:107::-;;;;;;:::i;:::-;;:::i;53449:33::-;;;;;;;;;;;;;;;;60367:171;;;;;;;;;;-1:-1:-1;60367:171:0;;;;;:::i;:::-;;:::i;53360:38::-;;;;;;;;;;;;53394:4;53360:38;;23390:334;;;;;;;;;;-1:-1:-1;23390:334:0;;;;;:::i;:::-;;:::i;59320:125::-;;;;;;;;;;-1:-1:-1;59320:125:0;;;;;:::i;:::-;;:::i;53651:28::-;;;;;;;;;;-1:-1:-1;53651:28:0;;;;-1:-1:-1;;;;;53651:28:0;;;53775:41;;;;;;;;;;-1:-1:-1;53775:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25264:164;;;;;;;;;;-1:-1:-1;25264:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;25385:25:0;;;25361:4;25385:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;25264:164;2636:192;;;;;;;;;;-1:-1:-1;2636:192:0;;;;;:::i;:::-;;:::i;58470:102::-;;;;;;:::i;:::-;;:::i;22101:305::-;22203:4;-1:-1:-1;;;;;;22240:40:0;;-1:-1:-1;;;22240:40:0;;:105;;-1:-1:-1;;;;;;;22297:48:0;;-1:-1:-1;;;22297:48:0;22240:105;:158;;;-1:-1:-1;;;;;;;;;;20799:40:0;;;22362:36;22220:178;22101:305;-1:-1:-1;;22101:305:0:o;23046:100::-;23100:13;23133:5;23126:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23046:100;:::o;24605:221::-;24681:7;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;24701:73;;;;-1:-1:-1;;;24701:73:0;;18119:2:1;24701:73:0;;;18101:21:1;18158:2;18138:18;;;18131:30;18197:34;18177:18;;;18170:62;-1:-1:-1;;;18248:18:1;;;18241:42;18300:19;;24701:73:0;;;;;;;;;-1:-1:-1;24794:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24794:24:0;;24605:221::o;24128:411::-;24209:13;24225:23;24240:7;24225:14;:23::i;:::-;24209:39;;24273:5;-1:-1:-1;;;;;24267:11:0;:2;-1:-1:-1;;;;;24267:11:0;;;24259:57;;;;-1:-1:-1;;;24259:57:0;;20904:2:1;24259:57:0;;;20886:21:1;20943:2;20923:18;;;20916:30;20982:34;20962:18;;;20955:62;-1:-1:-1;;;21033:18:1;;;21026:31;21074:19;;24259:57:0;20702:397:1;24259:57:0;684:10;-1:-1:-1;;;;;24351:21:0;;;;:62;;-1:-1:-1;24376:37:0;24393:5;684:10;25264:164;:::i;24376:37::-;24329:168;;;;-1:-1:-1;;;24329:168:0;;15408:2:1;24329:168:0;;;15390:21:1;15447:2;15427:18;;;15420:30;15486:34;15466:18;;;15459:62;15557:26;15537:18;;;15530:54;15601:19;;24329:168:0;15206:420:1;24329:168:0;24510:21;24519:2;24523:7;24510:8;:21::i;:::-;24198:341;24128:411;;:::o;59759:102::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;59828:13:::1;:25:::0;;-1:-1:-1;;;;;;59828:25:0::1;-1:-1:-1::0;;;;;59828:25:0;;;::::1;::::0;;;::::1;::::0;;59759:102::o;58808:94::-;58853:7;58880:14;:4;41921:14;;41829:114;58880:14;58873:21;;58808:94;:::o;60070:138::-;60162:38;60182:4;60188:2;60192:7;60162:19;:38::i;58330:97::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58399:12:::1;:20:::0;58330:97::o;59134:143::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;59232:37:::1;::::0;59200:21:::1;::::0;59240:10:::1;::::0;59232:37;::::1;;;::::0;59200:21;;59182:15:::1;59232:37:::0;59182:15;59232:37;59200:21;59240:10;59232:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;59171:106;59134:143::o:0;60216:::-;60312:39;60329:4;60335:2;60339:7;60312:39;;;;;;;;;;;;:16;:39::i;56389:842::-;54125:9;54138:10;54125:23;54117:63;;;;-1:-1:-1;;;54117:63:0;;;;;;;:::i;:::-;56472:19:::1;56494:14;:4;41921:14:::0;;41829:114;56494:14:::1;56538:11;::::0;:36:::1;::::0;-1:-1:-1;;;56538:36:0;;56563:10:::1;56538:36;::::0;::::1;7642:51:1::0;56472:36:0;;-1:-1:-1;56519:16:0::1;::::0;-1:-1:-1;;;;;56538:11:0;;::::1;::::0;:24:::1;::::0;7615:18:1;;56538:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56519:55;;56595:12;;56611:1;56595:17;56587:65;;;::::0;-1:-1:-1;;;56587:65:0;;15004:2:1;56587:65:0::1;::::0;::::1;14986:21:1::0;15043:2;15023:18;;;15016:30;15082:34;15062:18;;;15055:62;-1:-1:-1;;;15133:18:1;;;15126:33;15176:19;;56587:65:0::1;14802:399:1::0;56587:65:0::1;56682:1;56671:8;:12;56663:60;;;::::0;-1:-1:-1;;;56663:60:0;;10779:2:1;56663:60:0::1;::::0;::::1;10761:21:1::0;10818:2;10798:18;;;10791:30;10857:34;10837:18;;;10830:62;-1:-1:-1;;;10908:18:1;;;10901:33;10951:19;;56663:60:0::1;10577:399:1::0;56663:60:0::1;56754:3;56742:8;:15;;56734:84;;;::::0;-1:-1:-1;;;56734:84:0;;20479:2:1;56734:84:0::1;::::0;::::1;20461:21:1::0;20518:2;20498:18;;;20491:30;20557:34;20537:18;;;20530:62;20628:26;20608:18;;;20601:54;20672:19;;56734:84:0::1;20277:420:1::0;56734:84:0::1;56837:9;:14:::0;56829:52:::1;;;::::0;-1:-1:-1;;;56829:52:0;;23178:2:1;56829:52:0::1;::::0;::::1;23160:21:1::0;23217:2;23197:18;;;23190:30;23256:27;23236:18;;;23229:55;23301:18;;56829:52:0::1;22976:349:1::0;56829:52:0::1;56907:1;56900:3;:8;;:28;;;;;56919:9;;56912:3;:16;;56900:28;56892:57;;;;-1:-1:-1::0;;;56892:57:0::1;;;;;;;:::i;:::-;56962:11;::::0;-1:-1:-1;;;;;56962:11:0::1;:36;56999:10;57011:14;57022:3:::0;57011:8;:14:::1;:::i;:::-;56962:64;::::0;-1:-1:-1;;;;;;56962:64:0::1;::::0;;;;;;-1:-1:-1;;;;;8389:32:1;;;56962:64:0::1;::::0;::::1;8371:51:1::0;8438:18;;;8431:34;8344:18;;56962:64:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57044:9;57039:126;57059:3;57055:1;:7;57039:126;;;57084:38;57094:10;57106:15;57120:1:::0;57106:11;:15:::1;:::i;:::-;57084:9;:38::i;:::-;57137:16;:4;42040:19:::0;;42058:1;42040:19;;;41951:127;57137:16:::1;57064:3:::0;::::1;::::0;::::1;:::i;:::-;;;;57039:126;;;;57182:41;57190:10;57202:3;57207:15;57182:41;;;;;;;;:::i;:::-;;;;;;;;56461:770;;56389:842:::0;:::o;57335:651::-;54125:9;54138:10;54125:23;54117:63;;;;-1:-1:-1;;;54117:63:0;;;;;;;:::i;:::-;57415:19:::1;57437:14;:4;41921:14:::0;;41829:114;57437:14:::1;57472:11;::::0;57415:36;;-1:-1:-1;;;;57472:11:0;::::1;;;57464:49;;;::::0;-1:-1:-1;;;57464:49:0;;22066:2:1;57464:49:0::1;::::0;::::1;22048:21:1::0;22105:2;22085:18;;;22078:30;22144:27;22124:18;;;22117:55;22189:18;;57464:49:0::1;21864:349:1::0;57464:49:0::1;53394:4;57551:11;;57532:16;;:30;;;;:::i;:::-;:41;;57524:82;;;::::0;-1:-1:-1;;;57524:82:0;;11947:2:1;57524:82:0::1;::::0;::::1;11929:21:1::0;11986:2;11966:18;;;11959:30;12025;12005:18;;;11998:58;12073:18;;57524:82:0::1;11745:352:1::0;57524:82:0::1;57644:9;57637:3;57625:9;;:15;;;;:::i;:::-;:28;57617:61;;;;-1:-1:-1::0;;;57617:61:0::1;;;;;;;:::i;:::-;57704:1;57697:3;:8;;:28;;;;;57716:9;;57709:3;:16;;57697:28;57689:57;;;;-1:-1:-1::0;;;57689:57:0::1;;;;;;;:::i;:::-;57764:9;57759:126;57779:3;57775:1;:7;57759:126;;;57804:38;57814:10;57826:15;57840:1:::0;57826:11;:15:::1;:::i;57804:38::-;57857:16;:4;42040:19:::0;;42058:1;42040:19;;;41951:127;57857:16:::1;57784:3:::0;::::1;::::0;::::1;:::i;:::-;;;;57759:126;;;;57902:40;57909:10;57921:3;57926:15;57902:40;;;;;;;;:::i;:::-;;;;;;;;57973:3;57953:16;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;57335:651:0:o;59908:88::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;59967:11:::1;:21:::0;;;::::1;;-1:-1:-1::0;;;59967:21:0::1;-1:-1:-1::0;;;;59967:21:0;;::::1;::::0;;;::::1;::::0;;59908:88::o;58193:91::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58261:9:::1;:15:::0;58193:91::o;22740:239::-;22812:7;22848:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22848:16:0;22883:19;22875:73;;;;-1:-1:-1;;;22875:73:0;;16244:2:1;22875:73:0;;;16226:21:1;16283:2;16263:18;;;16256:30;16322:34;16302:18;;;16295:62;-1:-1:-1;;;16373:18:1;;;16366:39;16422:19;;22875:73:0;16042:405:1;55675:660:0;54125:9;54138:10;54125:23;54117:63;;;;-1:-1:-1;;;54117:63:0;;;;;;;:::i;:::-;55756:19:::1;55778:14;:4;41921:14:::0;;41829:114;55778:14:::1;55756:36;;55813:12;;55829:1;55813:17;55805:59;;;::::0;-1:-1:-1;;;55805:59:0;;18893:2:1;55805:59:0::1;::::0;::::1;18875:21:1::0;18932:2;18912:18;;;18905:30;18971:31;18951:18;;;18944:59;19020:18;;55805:59:0::1;18691:353:1::0;55805:59:0::1;53394:4;55897:11;;55883;:25;;;;:::i;:::-;:36;;55875:82;;;::::0;-1:-1:-1;;;55875:82:0;;20077:2:1;55875:82:0::1;::::0;::::1;20059:21:1::0;20116:2;20096:18;;;20089:30;20155:34;20135:18;;;20128:62;-1:-1:-1;;;20206:18:1;;;20199:31;20247:19;;55875:82:0::1;19875:397:1::0;55875:82:0::1;55995:9;55988:3;55976:9;;:15;;;;:::i;:::-;:28;55968:61;;;;-1:-1:-1::0;;;55968:61:0::1;;;;;;;:::i;:::-;56055:1;56048:3;:8;;:28;;;;;56067:9;;56060:3;:16;;56048:28;56040:57;;;;-1:-1:-1::0;;;56040:57:0::1;;;;;;;:::i;:::-;56115:9;56110:126;56130:3;56126:1;:7;56110:126;;;56155:38;56165:10;56177:15;56191:1:::0;56177:11;:15:::1;:::i;56155:38::-;56208:16;:4;42040:19:::0;;42058:1;42040:19;;;41951:127;56208:16:::1;56135:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56110:126;;22470:208:::0;22542:7;-1:-1:-1;;;;;22570:19:0;;22562:74;;;;-1:-1:-1;;;22562:74:0;;15833:2:1;22562:74:0;;;15815:21:1;15872:2;15852:18;;;15845:30;15911:34;15891:18;;;15884:62;-1:-1:-1;;;15962:18:1;;;15955:40;16012:19;;22562:74:0;15631:406:1;22562:74:0;-1:-1:-1;;;;;;22654:16:0;;;;;:9;:16;;;;;;;22470:208::o;2387:94::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;2452:21:::1;2470:1;2452:9;:21::i;:::-;2387:94::o:0;54305:306::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;54371:19:::1;54393:14;:4;41921:14:::0;;41829:114;54393:14:::1;54371:36;;54425:9;54420:126;54440:3;54436:1;:7;54420:126;;;54465:38;54475:10;54487:15;54501:1:::0;54487:11;:15:::1;:::i;54465:38::-;54518:16;:4;42040:19:::0;;42058:1;42040:19;;;41951:127;54518:16:::1;54445:3:::0;::::1;::::0;::::1;:::i;:::-;;;;54420:126;;;;54563:40;54570:10;54582:3;54587:15;54563:40;;;;;;;;:::i;:::-;;;;;;;;54360:251;54305:306:::0;:::o;58037:105::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58111:17:::1;:23:::0;58037:105::o;23215:104::-;23271:13;23304:7;23297:14;;;;;:::i;54673:926::-;54125:9;54138:10;54125:23;54117:63;;;;-1:-1:-1;;;54117:63:0;;;;;;;:::i;:::-;54799:19:::1;54821:14;:4;41921:14:::0;;41829:114;54821:14:::1;54799:36;;54856:12;;54872:1;54856:17;54848:62;;;::::0;-1:-1:-1;;;54848:62:0;;13068:2:1;54848:62:0::1;::::0;::::1;13050:21:1::0;;;13087:18;;;13080:30;13146:34;13126:18;;;13119:62;13198:18;;54848:62:0::1;12866:356:1::0;54848:62:0::1;54944:17;;54929:11;:32;;54921:78;;;::::0;-1:-1:-1;;;54921:78:0;;22420:2:1;54921:78:0::1;::::0;::::1;22402:21:1::0;22459:2;22439:18;;;22432:30;22498:34;22478:18;;;22471:62;-1:-1:-1;;;22549:18:1;;;22542:31;22590:19;;54921:78:0::1;22218:397:1::0;54921:78:0::1;55019:10;55030:5;;55019:17;;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;;::::1;;55018:18;55010:44;;;::::0;-1:-1:-1;;;55010:44:0;;21724:2:1;55010:44:0::1;::::0;::::1;21706:21:1::0;21763:2;21743:18;;;21736:30;-1:-1:-1;;;21782:18:1;;;21775:43;21835:18;;55010:44:0::1;21522:337:1::0;55010:44:0::1;55092:9;55085:3;55073:9;;:15;;;;:::i;:::-;:28;55065:61;;;;-1:-1:-1::0;;;55065:61:0::1;;;;;;;:::i;:::-;55152:1;55145:3;:8;;:28;;;;;55164:9;;55157:3;:16;;55145:28;55137:57;;;;-1:-1:-1::0;;;55137:57:0::1;;;;;;;:::i;:::-;55213:76;55257:10;55269:3;55274:5;;55240:40;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55230:51;;;;;;55283:5;;55213:16;:76::i;:::-;55205:112;;;::::0;-1:-1:-1;;;55205:112:0;;17767:2:1;55205:112:0::1;::::0;::::1;17749:21:1::0;17806:2;17786:18;;;17779:30;17845:25;17825:18;;;17818:53;17888:18;;55205:112:0::1;17565:347:1::0;55205:112:0::1;55350:4;55330:10;55341:5;;55330:17;;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:24;;;::::1;;-1:-1:-1::0;;55330:24:0;;::::1;::::0;;;::::1;::::0;;:17:::1;55367:126;55387:3;55383:1;:7;55367:126;;;55412:38;55422:10;55434:15;55448:1:::0;55434:11;:15:::1;:::i;55412:38::-;55465:16;:4;42040:19:::0;;42058:1;42040:19;;;41951:127;55465:16:::1;55392:3:::0;::::1;::::0;::::1;:::i;:::-;;;;55367:126;;;;55510:47;55524:10;55536:3;55541:15;55510:47;;;;;;;;:::i;:::-;;;;;;;;55588:3;55568:16;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;;54673:926:0:o;24898:295::-;-1:-1:-1;;;;;25001:24:0;;684:10;25001:24;;24993:62;;;;-1:-1:-1;;;24993:62:0;;13834:2:1;24993:62:0;;;13816:21:1;13873:2;13853:18;;;13846:30;13912:27;13892:18;;;13885:55;13957:18;;24993:62:0;13632:349:1;24993:62:0;684:10;25068:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;25068:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;25068:53:0;;;;;;;;;;25137:48;;8966:41:1;;;25068:42:0;;684:10;25137:48;;8939:18:1;25137:48:0;;;;;;;24898:295;;:::o;58653:107::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58734:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;60367:171::-:0;60482:48;60506:4;60512:2;60516:7;60525:4;60482:23;:48::i;:::-;60367:171;;;;:::o;23390:334::-;28064:4;28088:16;;;:7;:16;;;;;;23463:13;;-1:-1:-1;;;;;28088:16:0;23489:76;;;;-1:-1:-1;;;23489:76:0;;19661:2:1;23489:76:0;;;19643:21:1;19700:2;19680:18;;;19673:30;19739:34;19719:18;;;19712:62;-1:-1:-1;;;19790:18:1;;;19783:45;19845:19;;23489:76:0;19459:411:1;23489:76:0;23578:21;23602:10;:8;:10::i;:::-;23578:34;;23654:1;23636:7;23630:21;:25;:86;;;;;;;;;;;;;;;;;23682:7;23691:18;:7;:16;:18::i;:::-;23665:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23630:86;23623:93;23390:334;-1:-1:-1;;;23390:334:0:o;59320:125::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;59400:11:::1;:37:::0;;-1:-1:-1;;;;;;59400:37:0::1;-1:-1:-1::0;;;;;59400:37:0;;;::::1;::::0;;;::::1;::::0;;59320:125::o;2636:192::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2725:22:0;::::1;2717:73;;;::::0;-1:-1:-1;;;2717:73:0;;12304:2:1;2717:73:0::1;::::0;::::1;12286:21:1::0;12343:2;12323:18;;;12316:30;12382:34;12362:18;;;12355:62;-1:-1:-1;;;12433:18:1;;;12426:36;12479:19;;2717:73:0::1;12102:402:1::0;2717:73:0::1;2801:19;2811:8;2801:9;:19::i;:::-;2636:192:::0;:::o;58470:102::-;1809:6;;-1:-1:-1;;;;;1809:6:0;684:10;1956:23;1948:68;;;;-1:-1:-1;;;1948:68:0;;;;;;;:::i;:::-;58545:9:::1;:19:::0;58470:102::o;31981:174::-;32056:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;32056:29:0;-1:-1:-1;;;;;32056:29:0;;;;;;;;:24;;32110:23;32056:24;32110:14;:23::i;:::-;-1:-1:-1;;;;;32101:46:0;;;;;;;;;;;31981:174;;:::o;25495:339::-;25690:41;684:10;25723:7;25690:18;:41::i;:::-;25682:103;;;;-1:-1:-1;;;25682:103:0;;;;;;;:::i;:::-;25798:28;25808:4;25814:2;25818:7;25798:9;:28::i;28983:110::-;29059:26;29069:2;29073:7;29059:26;;;;;;;;;;;;:9;:26::i;2836:173::-;2911:6;;;-1:-1:-1;;;;;2928:17:0;;;-1:-1:-1;;;;;;2928:17:0;;;;;;;2961:40;;2911:6;;;2928:17;2911:6;;2961:40;;2892:16;;2961:40;2881:128;2836:173;:::o;59498:218::-;59581:4;59598:14;59615:29;:4;50716:58;;7353:66:1;50716:58:0;;;7341:79:1;7436:12;;;7429:28;;;50583:7:0;;7473:12:1;;50716:58:0;;;;;;;;;;;;50706:69;;;;;;50699:76;;50514:269;;;;59615:29;59598:46;;59689:19;59704:3;;59689:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59689:6:0;;:19;-1:-1:-1;;59689:14:0;:19;-1:-1:-1;59689:19:0:i;:::-;59672:13;;-1:-1:-1;;;;;59672:36:0;;;:13;;:36;;59498:218;-1:-1:-1;;;;;59498:218:0:o;26161:328::-;26336:41;684:10;26369:7;26336:18;:41::i;:::-;26328:103;;;;-1:-1:-1;;;26328:103:0;;;;;;;:::i;:::-;26442:39;26456:4;26462:2;26466:7;26475:5;26442:13;:39::i;58964:100::-;59016:13;59049:7;59042:14;;;;;:::i;18225:723::-;18281:13;18502:10;18498:53;;-1:-1:-1;;18529:10:0;;;;;;;;;;;;-1:-1:-1;;;18529:10:0;;;;;18225:723::o;18498:53::-;18576:5;18561:12;18617:78;18624:9;;18617:78;;18650:8;;;;:::i;:::-;;-1:-1:-1;18673:10:0;;-1:-1:-1;18681:2:0;18673:10;;:::i;:::-;;;18617:78;;;18705:19;18737:6;18727:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18727:17:0;;18705:39;;18755:154;18762:10;;18755:154;;18789:11;18799:1;18789:11;;:::i;:::-;;-1:-1:-1;18858:10:0;18866:2;18858:5;:10;:::i;:::-;18845:24;;:2;:24;:::i;:::-;18832:39;;18815:6;18822;18815:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;18815:56:0;;;;;;;;-1:-1:-1;18886:11:0;18895:2;18886:11;;:::i;:::-;;;18755:154;;;18933:6;18225:723;-1:-1:-1;;;;18225:723:0:o;28293:348::-;28386:4;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;28403:73;;;;-1:-1:-1;;;28403:73:0;;14591:2:1;28403:73:0;;;14573:21:1;14630:2;14610:18;;;14603:30;14669:34;14649:18;;;14642:62;-1:-1:-1;;;14720:18:1;;;14713:42;14772:19;;28403:73:0;14389:408:1;28403:73:0;28487:13;28503:23;28518:7;28503:14;:23::i;:::-;28487:39;;28556:5;-1:-1:-1;;;;;28545:16:0;:7;-1:-1:-1;;;;;28545:16:0;;:51;;;;28589:7;-1:-1:-1;;;;;28565:31:0;:20;28577:7;28565:11;:20::i;:::-;-1:-1:-1;;;;;28565:31:0;;28545:51;:87;;;-1:-1:-1;;;;;;25385:25:0;;;25361:4;25385:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;28600:32;25264:164;31285:578;31444:4;-1:-1:-1;;;;;31417:31:0;:23;31432:7;31417:14;:23::i;:::-;-1:-1:-1;;;;;31417:31:0;;31409:85;;;;-1:-1:-1;;;31409:85:0;;19251:2:1;31409:85:0;;;19233:21:1;19290:2;19270:18;;;19263:30;19329:34;19309:18;;;19302:62;-1:-1:-1;;;19380:18:1;;;19373:39;19429:19;;31409:85:0;19049:405:1;31409:85:0;-1:-1:-1;;;;;31513:16:0;;31505:65;;;;-1:-1:-1;;;31505:65:0;;13429:2:1;31505:65:0;;;13411:21:1;13468:2;13448:18;;;13441:30;13507:34;13487:18;;;13480:62;-1:-1:-1;;;13558:18:1;;;13551:34;13602:19;;31505:65:0;13227:400:1;31505:65:0;31687:29;31704:1;31708:7;31687:8;:29::i;:::-;-1:-1:-1;;;;;31729:15:0;;;;;;:9;:15;;;;;:20;;31748:1;;31729:15;:20;;31748:1;;31729:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31760:13:0;;;;;;:9;:13;;;;;:18;;31777:1;;31760:13;:18;;31777:1;;31760:18;:::i;:::-;;;;-1:-1:-1;;31789:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31789:21:0;-1:-1:-1;;;;;31789:21:0;;;;;;;;;31828:27;;31789:16;;31828:27;;;;;;;31285:578;;;:::o;29320:321::-;29450:18;29456:2;29460:7;29450:5;:18::i;:::-;29501:54;29532:1;29536:2;29540:7;29549:5;29501:22;:54::i;:::-;29479:154;;;;-1:-1:-1;;;29479:154:0;;;;;;;:::i;46665:231::-;46743:7;46764:17;46783:18;46805:27;46816:4;46822:9;46805:10;:27::i;:::-;46763:69;;;;46843:18;46855:5;46843:11;:18::i;:::-;-1:-1:-1;46879:9:0;46665:231;-1:-1:-1;;;46665:231:0:o;27371:315::-;27528:28;27538:4;27544:2;27548:7;27528:9;:28::i;:::-;27575:48;27598:4;27604:2;27608:7;27617:5;27575:22;:48::i;:::-;27567:111;;;;-1:-1:-1;;;27567:111:0;;;;;;;:::i;29977:382::-;-1:-1:-1;;;;;30057:16:0;;30049:61;;;;-1:-1:-1;;;30049:61:0;;17406:2:1;30049:61:0;;;17388:21:1;;;17425:18;;;17418:30;17484:34;17464:18;;;17457:62;17536:18;;30049:61:0;17204:356:1;30049:61:0;28064:4;28088:16;;;:7;:16;;;;;;-1:-1:-1;;;;;28088:16:0;:30;30121:58;;;;-1:-1:-1;;;30121:58:0;;12711:2:1;30121:58:0;;;12693:21:1;12750:2;12730:18;;;12723:30;12789;12769:18;;;12762:58;12837:18;;30121:58:0;12509:352:1;30121:58:0;-1:-1:-1;;;;;30250:13:0;;;;;;:9;:13;;;;;:18;;30267:1;;30250:13;:18;;30267:1;;30250:18;:::i;:::-;;;;-1:-1:-1;;30279:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;30279:21:0;-1:-1:-1;;;;;30279:21:0;;;;;;;;30318:33;;30279:16;;;30318:33;;30279:16;;30318:33;29977:382;;:::o;32720:799::-;32875:4;-1:-1:-1;;;;;32896:13:0;;10987:20;11035:8;32892:620;;32932:72;;-1:-1:-1;;;32932:72:0;;-1:-1:-1;;;;;32932:36:0;;;;;:72;;684:10;;32983:4;;32989:7;;32998:5;;32932:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32932:72:0;;;;;;;;-1:-1:-1;;32932:72:0;;;;;;;;;;;;:::i;:::-;;;32928:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33174:13:0;;33170:272;;33217:60;;-1:-1:-1;;;33217:60:0;;;;;;;:::i;33170:272::-;33392:6;33386:13;33377:6;33373:2;33369:15;33362:38;32928:529;-1:-1:-1;;;;;;33055:51:0;-1:-1:-1;;;33055:51:0;;-1:-1:-1;33048:58:0;;32892:620;-1:-1:-1;33496:4:0;32720:799;;;;;;:::o;44555:1308::-;44636:7;44645:12;44870:9;:16;44890:2;44870:22;44866:990;;;45166:4;45151:20;;45145:27;45216:4;45201:20;;45195:27;45274:4;45259:20;;45253:27;44909:9;45245:36;45317:25;45328:4;45245:36;45145:27;45195;45317:10;:25::i;:::-;45310:32;;;;;;;;;44866:990;45364:9;:16;45384:2;45364:22;45360:496;;;45639:4;45624:20;;45618:27;45690:4;45675:20;;45669:27;45732:23;45743:4;45618:27;45669;45732:10;:23::i;:::-;45725:30;;;;;;;;45360:496;-1:-1:-1;45804:1:0;;-1:-1:-1;45808:35:0;45360:496;44555:1308;;;;;:::o;42826:643::-;42904:20;42895:5;:29;;;;;;;;:::i;:::-;;42891:571;;;42826:643;:::o;42891:571::-;43002:29;42993:5;:38;;;;;;;;:::i;:::-;;42989:473;;;43048:34;;-1:-1:-1;;;43048:34:0;;10066:2:1;43048:34:0;;;10048:21:1;10105:2;10085:18;;;10078:30;10144:26;10124:18;;;10117:54;10188:18;;43048:34:0;9864:348:1;42989:473:0;43113:35;43104:5;:44;;;;;;;;:::i;:::-;;43100:362;;;43165:41;;-1:-1:-1;;;43165:41:0;;10419:2:1;43165:41:0;;;10401:21:1;10458:2;10438:18;;;10431:30;10497:33;10477:18;;;10470:61;10548:18;;43165:41:0;10217:355:1;43100:362:0;43237:30;43228:5;:39;;;;;;;;:::i;:::-;;43224:238;;;43284:44;;-1:-1:-1;;;43284:44:0;;14188:2:1;43284:44:0;;;14170:21:1;14227:2;14207:18;;;14200:30;14266:34;14246:18;;;14239:62;-1:-1:-1;;;14317:18:1;;;14310:32;14359:19;;43284:44:0;13986:398:1;43224:238:0;43359:30;43350:5;:39;;;;;;;;:::i;:::-;;43346:116;;;43406:44;;-1:-1:-1;;;43406:44:0;;17003:2:1;43406:44:0;;;16985:21:1;17042:2;17022:18;;;17015:30;17081:34;17061:18;;;17054:62;-1:-1:-1;;;17132:18:1;;;17125:32;17174:19;;43406:44:0;16801:398:1;48164:1632:0;48295:7;;49229:66;49216:79;;49212:163;;;-1:-1:-1;49328:1:0;;-1:-1:-1;49332:30:0;49312:51;;49212:163;49389:1;:7;;49394:2;49389:7;;:18;;;;;49400:1;:7;;49405:2;49400:7;;49389:18;49385:102;;;-1:-1:-1;49440:1:0;;-1:-1:-1;49444:30:0;49424:51;;49385:102;49601:24;;;49584:14;49601:24;;;;;;;;;9245:25:1;;;9318:4;9306:17;;9286:18;;;9279:45;;;;9340:18;;;9333:34;;;9383:18;;;9376:34;;;49601:24:0;;9217:19:1;;49601:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49601:24:0;;-1:-1:-1;;49601:24:0;;;-1:-1:-1;;;;;;;49640:20:0;;49636:103;;49693:1;49697:29;49677:50;;;;;;;49636:103;49759:6;-1:-1:-1;49767:20:0;;-1:-1:-1;48164:1632:0;;;;;;;;:::o;47159:391::-;47273:7;;-1:-1:-1;;;;;47374:75:0;;47476:3;47472:12;;;47486:2;47468:21;47517:25;47528:4;47468:21;47537:1;47374:75;47517:10;:25::i;:::-;47510:32;;;;;;47159:391;;;;;;:::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:347;1044:8;1054:6;1108:3;1101:4;1093:6;1089:17;1085:27;1075:55;;1126:1;1123;1116:12;1075:55;-1:-1:-1;1149:20:1;;1192:18;1181:30;;1178:50;;;1224:1;1221;1214:12;1178:50;1261:4;1253:6;1249:17;1237:29;;1313:3;1306:4;1297:6;1289;1285:19;1281:30;1278:39;1275:59;;;1330:1;1327;1320:12;1345:186;1404:6;1457:2;1445:9;1436:7;1432:23;1428:32;1425:52;;;1473:1;1470;1463:12;1425:52;1496:29;1515:9;1496:29;:::i;1536:260::-;1604:6;1612;1665:2;1653:9;1644:7;1640:23;1636:32;1633:52;;;1681:1;1678;1671:12;1633:52;1704:29;1723:9;1704:29;:::i;:::-;1694:39;;1752:38;1786:2;1775:9;1771:18;1752:38;:::i;:::-;1742:48;;1536:260;;;;;:::o;1801:328::-;1878:6;1886;1894;1947:2;1935:9;1926:7;1922:23;1918:32;1915:52;;;1963:1;1960;1953:12;1915:52;1986:29;2005:9;1986:29;:::i;:::-;1976:39;;2034:38;2068:2;2057:9;2053:18;2034:38;:::i;:::-;2024:48;;2119:2;2108:9;2104:18;2091:32;2081:42;;1801:328;;;;;:::o;2134:666::-;2229:6;2237;2245;2253;2306:3;2294:9;2285:7;2281:23;2277:33;2274:53;;;2323:1;2320;2313:12;2274:53;2346:29;2365:9;2346:29;:::i;:::-;2336:39;;2394:38;2428:2;2417:9;2413:18;2394:38;:::i;:::-;2384:48;;2479:2;2468:9;2464:18;2451:32;2441:42;;2534:2;2523:9;2519:18;2506:32;2561:18;2553:6;2550:30;2547:50;;;2593:1;2590;2583:12;2547:50;2616:22;;2669:4;2661:13;;2657:27;-1:-1:-1;2647:55:1;;2698:1;2695;2688:12;2647:55;2721:73;2786:7;2781:2;2768:16;2763:2;2759;2755:11;2721:73;:::i;:::-;2711:83;;;2134:666;;;;;;;:::o;2805:254::-;2870:6;2878;2931:2;2919:9;2910:7;2906:23;2902:32;2899:52;;;2947:1;2944;2937:12;2899:52;2970:29;2989:9;2970:29;:::i;:::-;2960:39;;3018:35;3049:2;3038:9;3034:18;3018:35;:::i;3064:254::-;3132:6;3140;3193:2;3181:9;3172:7;3168:23;3164:32;3161:52;;;3209:1;3206;3199:12;3161:52;3232:29;3251:9;3232:29;:::i;:::-;3222:39;3308:2;3293:18;;;;3280:32;;-1:-1:-1;;;3064:254:1:o;3323:180::-;3379:6;3432:2;3420:9;3411:7;3407:23;3403:32;3400:52;;;3448:1;3445;3438:12;3400:52;3471:26;3487:9;3471:26;:::i;3508:245::-;3566:6;3619:2;3607:9;3598:7;3594:23;3590:32;3587:52;;;3635:1;3632;3625:12;3587:52;3674:9;3661:23;3693:30;3717:5;3693:30;:::i;3758:249::-;3827:6;3880:2;3868:9;3859:7;3855:23;3851:32;3848:52;;;3896:1;3893;3886:12;3848:52;3928:9;3922:16;3947:30;3971:5;3947:30;:::i;4012:786::-;4112:6;4120;4128;4136;4144;4197:2;4185:9;4176:7;4172:23;4168:32;4165:52;;;4213:1;4210;4203:12;4165:52;4253:9;4240:23;4282:18;4323:2;4315:6;4312:14;4309:34;;;4339:1;4336;4329:12;4309:34;4378:58;4428:7;4419:6;4408:9;4404:22;4378:58;:::i;:::-;4455:8;;-1:-1:-1;4352:84:1;-1:-1:-1;4537:2:1;4522:18;;4509:32;;-1:-1:-1;4594:2:1;4579:18;;4566:32;;-1:-1:-1;4610:16:1;;;4607:36;;;4639:1;4636;4629:12;4607:36;;4678:60;4730:7;4719:8;4708:9;4704:24;4678:60;:::i;:::-;4012:786;;;;-1:-1:-1;4012:786:1;;-1:-1:-1;4757:8:1;;4652:86;4012:786;-1:-1:-1;;;4012:786:1:o;4803:450::-;4872:6;4925:2;4913:9;4904:7;4900:23;4896:32;4893:52;;;4941:1;4938;4931:12;4893:52;4981:9;4968:23;5014:18;5006:6;5003:30;5000:50;;;5046:1;5043;5036:12;5000:50;5069:22;;5122:4;5114:13;;5110:27;-1:-1:-1;5100:55:1;;5151:1;5148;5141:12;5100:55;5174:73;5239:7;5234:2;5221:16;5216:2;5212;5208:11;5174:73;:::i;5258:180::-;5317:6;5370:2;5358:9;5349:7;5345:23;5341:32;5338:52;;;5386:1;5383;5376:12;5338:52;-1:-1:-1;5409:23:1;;5258:180;-1:-1:-1;5258:180:1:o;5443:184::-;5513:6;5566:2;5554:9;5545:7;5541:23;5537:32;5534:52;;;5582:1;5579;5572:12;5534:52;-1:-1:-1;5605:16:1;;5443:184;-1:-1:-1;5443:184:1:o;5632:257::-;5673:3;5711:5;5705:12;5738:6;5733:3;5726:19;5754:63;5810:6;5803:4;5798:3;5794:14;5787:4;5780:5;5776:16;5754:63;:::i;:::-;5871:2;5850:15;-1:-1:-1;;5846:29:1;5837:39;;;;5878:4;5833:50;;5632:257;-1:-1:-1;;5632:257:1:o;5894:459::-;6146:26;6142:31;6133:6;6129:2;6125:15;6121:53;6116:3;6109:66;6205:6;6200:2;6195:3;6191:12;6184:28;6256:6;6248;6243:2;6238:3;6234:12;6221:42;6091:3;6286:16;;6304:2;6282:25;6316:13;;;6282:25;5894:459;-1:-1:-1;;;5894:459:1:o;6358:273::-;6543:6;6535;6530:3;6517:33;6499:3;6569:16;;6594:13;;;6569:16;6358:273;-1:-1:-1;6358:273:1:o;6636:470::-;6815:3;6853:6;6847:13;6869:53;6915:6;6910:3;6903:4;6895:6;6891:17;6869:53;:::i;:::-;6985:13;;6944:16;;;;7007:57;6985:13;6944:16;7041:4;7029:17;;7007:57;:::i;:::-;7080:20;;6636:470;-1:-1:-1;;;;6636:470:1:o;7704:488::-;-1:-1:-1;;;;;7973:15:1;;;7955:34;;8025:15;;8020:2;8005:18;;7998:43;8072:2;8057:18;;8050:34;;;8120:3;8115:2;8100:18;;8093:31;;;7898:4;;8141:45;;8166:19;;8158:6;8141:45;:::i;:::-;8133:53;7704:488;-1:-1:-1;;;;;;7704:488:1:o;8476:345::-;-1:-1:-1;;;;;8696:32:1;;;;8678:51;;8760:2;8745:18;;8738:34;;;;8803:2;8788:18;;8781:34;8666:2;8651:18;;8476:345::o;9640:219::-;9789:2;9778:9;9771:21;9752:4;9809:44;9849:2;9838:9;9834:18;9826:6;9809:44;:::i;10981:340::-;11183:2;11165:21;;;11222:2;11202:18;;;11195:30;-1:-1:-1;;;11256:2:1;11241:18;;11234:46;11312:2;11297:18;;10981:340::o;11326:414::-;11528:2;11510:21;;;11567:2;11547:18;;;11540:30;11606:34;11601:2;11586:18;;11579:62;-1:-1:-1;;;11672:2:1;11657:18;;11650:48;11730:3;11715:19;;11326:414::o;16452:344::-;16654:2;16636:21;;;16693:2;16673:18;;;16666:30;-1:-1:-1;;;16727:2:1;16712:18;;16705:50;16787:2;16772:18;;16452:344::o;18330:356::-;18532:2;18514:21;;;18551:18;;;18544:30;18610:34;18605:2;18590:18;;18583:62;18677:2;18662:18;;18330:356::o;21104:413::-;21306:2;21288:21;;;21345:2;21325:18;;;21318:30;21384:34;21379:2;21364:18;;21357:62;-1:-1:-1;;;21450:2:1;21435:18;;21428:47;21507:3;21492:19;;21104:413::o;22620:351::-;22822:2;22804:21;;;22861:2;22841:18;;;22834:30;22900:29;22895:2;22880:18;;22873:57;22962:2;22947:18;;22620:351::o;23512:128::-;23552:3;23583:1;23579:6;23576:1;23573:13;23570:39;;;23589:18;;:::i;:::-;-1:-1:-1;23625:9:1;;23512:128::o;23645:120::-;23685:1;23711;23701:35;;23716:18;;:::i;:::-;-1:-1:-1;23750:9:1;;23645:120::o;23770:168::-;23810:7;23876:1;23872;23868:6;23864:14;23861:1;23858:21;23853:1;23846:9;23839:17;23835:45;23832:71;;;23883:18;;:::i;:::-;-1:-1:-1;23923:9:1;;23770:168::o;23943:125::-;23983:4;24011:1;24008;24005:8;24002:34;;;24016:18;;:::i;:::-;-1:-1:-1;24053:9:1;;23943:125::o;24073:258::-;24145:1;24155:113;24169:6;24166:1;24163:13;24155:113;;;24245:11;;;24239:18;24226:11;;;24219:39;24191:2;24184:10;24155:113;;;24286:6;24283:1;24280:13;24277:48;;;-1:-1:-1;;24321:1:1;24303:16;;24296:27;24073:258::o;24336:380::-;24415:1;24411:12;;;;24458;;;24479:61;;24533:4;24525:6;24521:17;24511:27;;24479:61;24586:2;24578:6;24575:14;24555:18;24552:38;24549:161;;;24632:10;24627:3;24623:20;24620:1;24613:31;24667:4;24664:1;24657:15;24695:4;24692:1;24685:15;24549:161;;24336:380;;;:::o;24721:135::-;24760:3;-1:-1:-1;;24781:17:1;;24778:43;;;24801:18;;:::i;:::-;-1:-1:-1;24848:1:1;24837:13;;24721:135::o;24861:112::-;24893:1;24919;24909:35;;24924:18;;:::i;:::-;-1:-1:-1;24958:9:1;;24861:112::o;24978:127::-;25039:10;25034:3;25030:20;25027:1;25020:31;25070:4;25067:1;25060:15;25094:4;25091:1;25084:15;25110:127;25171:10;25166:3;25162:20;25159:1;25152:31;25202:4;25199:1;25192:15;25226:4;25223:1;25216:15;25242:127;25303:10;25298:3;25294:20;25291:1;25284:31;25334:4;25331:1;25324:15;25358:4;25355:1;25348:15;25374:127;25435:10;25430:3;25426:20;25423:1;25416:31;25466:4;25463:1;25456:15;25490:4;25487:1;25480:15;25506:127;25567:10;25562:3;25558:20;25555:1;25548:31;25598:4;25595:1;25588:15;25622:4;25619:1;25612:15;25638:131;-1:-1:-1;;;;;;25712:32:1;;25702:43;;25692:71;;25759:1;25756;25749:12

Swarm Source

ipfs://47f1f7106e00bbfc5aa259ab551f91e1f6b2b04562761a417817056f2b95b81a

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