Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity ^0.8.0;

import "./ERC721Tradable.sol";

contract Degenerator is ERC721Tradable {
    using Counters for Counters.Counter;

    mapping (address => bool) private _whitelist;
    mapping (address => uint) private _numMinted;
    uint public _supplyLimit;
    uint public _mintLimit = 3;
    uint public _txnLimit = 3;
    uint public _mintPrice = 2 * 10 ** 17;
    bool public _whiteListOnly = true;
    bool public _mintingEnabled = false;
    bool public _transferLimit = true;
    bool public _noTransfers = false;


    constructor(
    ) ERC721Tradable("Degenerator S01", "DEGEN01", 0xa5409ec958C83C3f309868babACA7c86DCB077c1) { }

    function baseTokenURI() override public pure returns (string memory) {
        return "https://degen.megaweapon.io/degen/s01/";
    }

    function mint(uint _numToMint) external payable {
        require (_mintingEnabled, "DEGEN: minting disabled");
        require (_numToMint > 0, "DEGEN: cannot mint 0 tokens");
        if (_whiteListOnly)
            require (_whitelist[msgSender()] == true, "DEGEN: must be whitelisted");
        require (_numToMint <= _txnLimit, "DEGEN: per txn mint limit exceeded");
        require (msg.value == (_mintPrice * _numToMint), "DEGEN: wrong value");
        uint i = 0;
        while (i < _numToMint) {
            uint256 currentTokenId = _nextTokenId.current();
            _nextTokenId.increment();
            _safeMint(msgSender(), currentTokenId);
            _numMinted[msgSender()]++;
            i++;
        }
        if (_supplyLimit != 0) 
            require (totalSupply() <= _supplyLimit, "DEGEN: total mint limit exceeded");
        if (_mintLimit != 0) 
            require (_numMinted[msgSender()] <= _mintLimit, "DEGEN: per account mint limit exceeded");
    }

    function addToWhitelist(address[] calldata addresses) external onlyOwner {
        require (addresses.length <= 100, "DEGEN: limit 100 addresses");
        uint i = 0;
        uint max = addresses.length;
        while (i < max) {
            _whitelist[addresses[i]] = true;
            i++;
        }
    }

    function isWhitelist(address account) external view returns (bool) {
        return _whitelist[account];
    }

    function setMintLimit(uint limit) external onlyOwner {
        require (limit != _mintLimit, "DEGEN: cannot set same mint limit");
        _mintLimit = limit;
    }
    
    function setSupplyLimit(uint limit) external onlyOwner {
        require (limit != _supplyLimit, "DEGEN: cannot set same supply limit");
        _supplyLimit = limit;
    }

    function setTxnLimit(uint limit) external onlyOwner {
        require (limit != _txnLimit, "DEGEN: cannot set same txn limit");
        _txnLimit = limit;
    }

    function setMintPrice(uint price) external onlyOwner {
        require (price != _mintPrice, "DEGEN: cannot set same price");
        _mintPrice = price;
    }

    function toggleWhitelist() external onlyOwner {
        _whiteListOnly = !_whiteListOnly;
    }

    function toggleMinting() external onlyOwner {
        _mintingEnabled = !_mintingEnabled;
    }

    function toggleTransferLimit() external onlyOwner {
        _transferLimit = !_transferLimit;
    }

    function toggleNoTransfers() external onlyOwner {
        _noTransfers = !_noTransfers;
    }

    function withdraw(uint amount) external onlyOwner {
        (bool sent, ) = _msgSender().call{value: amount}("");
        require (sent, "DEGEN: withdraw failed");
    }

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override {
        require (_noTransfers == false || _mintingEnabled == true, "DEGEN: no transfers at this time");
        if (_transferLimit == true && _mintLimit != 0)
            require (balanceOf(to) <= _mintLimit, "DEGEN: account token limit exceeded");
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.0;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import {Initializable} from "./Initializable.sol";

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @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: address zero is not a valid owner");
        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 overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

        _afterTokenTransfer(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 from incorrect owner");
        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);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./IERC721Enumerable.sol";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./Ownable.sol";
import "./Counters.sol";
import "./Strings.sol";
import "./SafeMath.sol";

import "./ContentMixin.sol";
import "./NativeMetaTransaction.sol";

contract OwnableDelegateProxy {}

/**
 * Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
 */
contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title ERC721Tradable
 * ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
 */
abstract contract ERC721Tradable is ERC721, ContextMixin, NativeMetaTransaction, Ownable {
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    /**
     * @dev
     * We rely on the OZ Counter util to keep track of the next available ID.
     * We track the nextTokenId instead of the currentTokenId to save users on gas costs. 
     * Read more about it here: https://shiny.mirror.xyz/OUampBbIz9ebEicfGnQf5At_ReMHlZy0tB4glb9xQ0E
     */ 
    Counters.Counter internal _nextTokenId;
    address proxyRegistryAddress;

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress
    ) ERC721(_name, _symbol) {
        proxyRegistryAddress = _proxyRegistryAddress;
        // nextTokenId is initialized to 1, since starting at 0 leads to higher gas cost for the first minter
        _nextTokenId.increment();
        _initializeEIP712(_name);
    }

    /**
     * @dev Mints a token to an address with a tokenURI.
     * @param _to address of the future owner of the token
     */
    function mintTo(address _to) public onlyOwner {
        uint256 currentTokenId = _nextTokenId.current();
        _nextTokenId.increment();
        _safeMint(_to, currentTokenId);
    }

    /**
        @dev Returns the total tokens minted so far.
        1 is always subtracted from the Counter since it tracks the next available tokenId.
     */
    function totalSupply() public view returns (uint256) {
        return _nextTokenId.current() - 1;
    }

    function baseTokenURI() virtual public pure returns (string memory);

    function tokenURI(uint256 _tokenId) override public pure returns (string memory) {
        return string(abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId)));
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address owner, address operator)
        override
        public
        view
        returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
        internal
        override
        view
        returns (address sender)
    {
        return ContextMixin.msgSender();
    }
}

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

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

    /**
     * @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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import {SafeMath} from  "./SafeMath.sol";
import {EIP712Base} from "./EIP712Base.sol";

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_noTransfers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_supplyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_transferLimit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_txnLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_whiteListOnly","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numToMint","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"setSupplyLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"setTxnLimit","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":[],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleNoTransfers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleTransferLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","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":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526006805460ff199081169091556003600f8190556010556702c68af0bb1400006011556012805462010000921660011762ffff0019169190911763ff000000191690553480156200005457600080fd5b506040518060400160405280600f81526020016e446567656e657261746f722053303160881b81525060405180604001604052806007815260200166444547454e303160c81b81525073a5409ec958c83c3f309868babaca7c86dcb077c182828160009080519060200190620000cc9291906200030c565b508051620000e29060019060208401906200030c565b505050620000ff620000f96200014660201b60201c565b62000163565b600b80546001600160a01b0319166001600160a01b03831617905562000132600a620001b5602090811b6200153917901c565b6200013d83620001be565b50505062000443565b60006200015d6200020860201b620015421760201c565b90505b90565b600980546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b80546001019055565b60065460ff1615620001ed5760405162461bcd60e51b8152600401620001e490620003de565b60405180910390fd5b620001f88162000266565b506006805460ff19166001179055565b6000333014156200026157600080368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b03169150620001609050565b503390565b6040518060800160405280604f815260200162003212604f913980516020918201208251838301206040805180820190915260018152603160f81b930192909252907fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc630620002d462000308565b604051620002ea959493929190602001620003b2565b60408051601f19818403018152919052805160209091012060075550565b4690565b8280546200031a9062000406565b90600052602060002090601f0160209004810192826200033e576000855562000389565b82601f106200035957805160ff191683800117855562000389565b8280016001018555821562000389579182015b82811115620003895782518255916020019190600101906200036c565b50620003979291506200039b565b5090565b5b808211156200039757600081556001016200039c565b948552602085019390935260408401919091526001600160a01b03166060830152608082015260a00190565b6020808252600e908201526d185b1c9958591e481a5b9a5d195960921b604082015260600190565b6002810460018216806200041b57607f821691505b602082108114156200043d57634e487b7160e01b600052602260045260246000fd5b50919050565b612dbf80620004536000396000f3fe6080604052600436106102675760003560e01c80637d55094d11610144578063b191a6fb116100b6578063da9b5fbd1161007a578063da9b5fbd14610680578063e985e9c514610695578063f1cf6409146106b5578063f2fde38b146106ca578063f4a0a528146106ea578063f74568cc1461070a57610267565b8063b191a6fb146105f6578063b88d4fde1461060b578063c683630d1461062b578063c87b56dd1461064b578063d547cfb71461066b57610267565b80638da5cb5b116101085780638da5cb5b1461056457806395d89b41146105795780639773aa781461058e5780639e6a1d7d146105a3578063a0712d68146105c3578063a22cb465146105d657610267565b80637d55094d146104f05780637e15144b146105055780637e8caef01461051a5780637f6497831461052f57806381b2069b1461054f57610267565b80632e1a7d4d116101dd57806348b856d4116101a157806348b856d41461045157806351573f79146104665780636352211e1461047b57806370a082311461049b578063715018a6146104bb578063755edd17146104d057610267565b80632e1a7d4d146103c75780633408e470146103e7578063361fab25146103fc5780633fa1cee71461041c57806342842e0e1461043157610267565b80630c53c51c1161022f5780630c53c51c146103355780630f7e59701461034857806318160ddd1461035d57806320379ee51461037257806323b872dd146103875780632d0335ab146103a757610267565b806301ffc9a71461026c5780630387da42146102a257806306fdde03146102c4578063081812fc146102e6578063095ea7b314610313575b600080fd5b34801561027857600080fd5b5061028c61028736600461216b565b61072a565b6040516102999190612326565b60405180910390f35b3480156102ae57600080fd5b506102b7610772565b6040516102999190612331565b3480156102d057600080fd5b506102d9610778565b604051610299919061237c565b3480156102f257600080fd5b506103066103013660046121bf565b61080b565b60405161029991906122a0565b34801561031f57600080fd5b5061033361032e3660046120d1565b610857565b005b6102d9610343366004612056565b6108ef565b34801561035457600080fd5b506102d9610a6f565b34801561036957600080fd5b506102b7610a8c565b34801561037e57600080fd5b506102b7610aa9565b34801561039357600080fd5b506103336103a2366004611f7b565b610aaf565b3480156103b357600080fd5b506102b76103c2366004611f27565b610ae7565b3480156103d357600080fd5b506103336103e23660046121bf565b610b02565b3480156103f357600080fd5b506102b7610bc8565b34801561040857600080fd5b506103336104173660046121bf565b610bcc565b34801561042857600080fd5b50610333610c32565b34801561043d57600080fd5b5061033361044c366004611f7b565b610c92565b34801561045d57600080fd5b5061028c610cad565b34801561047257600080fd5b506102b7610cbc565b34801561048757600080fd5b506103066104963660046121bf565b610cc2565b3480156104a757600080fd5b506102b76104b6366004611f27565b610cf7565b3480156104c757600080fd5b50610333610d3b565b3480156104dc57600080fd5b506103336104eb366004611f27565b610d86565b3480156104fc57600080fd5b50610333610de7565b34801561051157600080fd5b50610333610e43565b34801561052657600080fd5b5061028c610e96565b34801561053b57600080fd5b5061033361054a3660046120fc565b610ea6565b34801561055b57600080fd5b5061028c610f8d565b34801561057057600080fd5b50610306610f9b565b34801561058557600080fd5b506102d9610faa565b34801561059a57600080fd5b506102b7610fb9565b3480156105af57600080fd5b506103336105be3660046121bf565b610fbf565b6103336105d13660046121bf565b611025565b3480156105e257600080fd5b506103336105f1366004612025565b611216565b34801561060257600080fd5b50610333611228565b34801561061757600080fd5b50610333610626366004611fbb565b611286565b34801561063757600080fd5b5061028c610646366004611f27565b6112bf565b34801561065757600080fd5b506102d96106663660046121bf565b6112dd565b34801561067757600080fd5b506102d9611317565b34801561068c57600080fd5b5061028c611337565b3480156106a157600080fd5b5061028c6106b0366004611f43565b611340565b3480156106c157600080fd5b506102b76113f6565b3480156106d657600080fd5b506103336106e5366004611f27565b6113fc565b3480156106f657600080fd5b506103336107053660046121bf565b61146d565b34801561071657600080fd5b506103336107253660046121bf565b6114d3565b60006001600160e01b031982166380ac58cd60e01b148061075b57506001600160e01b03198216635b5e139f60e01b145b8061076a575061076a8261159e565b90505b919050565b60115481565b60606000805461078790612c49565b80601f01602080910402602001604051908101604052809291908181526020018280546107b390612c49565b80156108005780601f106107d557610100808354040283529160200191610800565b820191906000526020600020905b8154815290600101906020018083116107e357829003601f168201915b505050505090505b90565b6000610816826115b7565b61083b5760405162461bcd60e51b81526004016108329061289d565b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b600061086282610cc2565b9050806001600160a01b0316836001600160a01b031614156108965760405162461bcd60e51b815260040161083290612a1e565b806001600160a01b03166108a86115d4565b6001600160a01b031614806108c457506108c4816106b06115d4565b6108e05760405162461bcd60e51b815260040161083290612715565b6108ea83836115de565b505050565b60408051606081810183526001600160a01b0388166000818152600860209081529085902054845283015291810186905261092d878287878761164c565b6109495760405162461bcd60e51b81526004016108329061291e565b6001600160a01b03871660009081526008602052604090205461096d9060016116f2565b6001600160a01b0388166000908152600860205260409081902091909155517f5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b906109bd90899033908a906122b4565b60405180910390a1600080306001600160a01b0316888a6040516020016109e592919061221f565b60408051601f19818403018152908290526109ff91612203565b6000604051808303816000865af19150503d8060008114610a3c576040519150601f19603f3d011682016040523d82523d6000602084013e610a41565b606091505b509150915081610a635760405162461bcd60e51b815260040161083290612493565b98975050505050505050565b604051806040016040528060018152602001603160f81b81525081565b60006001610a9a600a611705565b610aa49190612c06565b905090565b60075490565b610ac0610aba6115d4565b82611709565b610adc5760405162461bcd60e51b815260040161083290612abb565b6108ea83838361178d565b6001600160a01b031660009081526008602052604090205490565b610b0a6115d4565b6001600160a01b0316610b1b610f9b565b6001600160a01b031614610b415760405162461bcd60e51b8152600401610832906128e9565b6000610b4b6115d4565b6001600160a01b031682604051610b6190610808565b60006040518083038185875af1925050503d8060008114610b9e576040519150601f19603f3d011682016040523d82523d6000602084013e610ba3565b606091505b5050905080610bc45760405162461bcd60e51b815260040161083290612a8b565b5050565b4690565b610bd46115d4565b6001600160a01b0316610be5610f9b565b6001600160a01b031614610c0b5760405162461bcd60e51b8152600401610832906128e9565b600e54811415610c2d5760405162461bcd60e51b815260040161083290612644565b600e55565b610c3a6115d4565b6001600160a01b0316610c4b610f9b565b6001600160a01b031614610c715760405162461bcd60e51b8152600401610832906128e9565b6012805463ff00000019811663010000009182900460ff1615909102179055565b6108ea83838360405180602001604052806000815250611286565b60125462010000900460ff1681565b600e5481565b6000818152600260205260408120546001600160a01b03168061076a5760405162461bcd60e51b815260040161083290612772565b60006001600160a01b038216610d1f5760405162461bcd60e51b8152600401610832906126cc565b506001600160a01b031660009081526003602052604090205490565b610d436115d4565b6001600160a01b0316610d54610f9b565b6001600160a01b031614610d7a5760405162461bcd60e51b8152600401610832906128e9565b610d8460006118c0565b565b610d8e6115d4565b6001600160a01b0316610d9f610f9b565b6001600160a01b031614610dc55760405162461bcd60e51b8152600401610832906128e9565b6000610dd1600a611705565b9050610ddd600a611539565b610bc48282611912565b610def6115d4565b6001600160a01b0316610e00610f9b565b6001600160a01b031614610e265760405162461bcd60e51b8152600401610832906128e9565b6012805461ff001981166101009182900460ff1615909102179055565b610e4b6115d4565b6001600160a01b0316610e5c610f9b565b6001600160a01b031614610e825760405162461bcd60e51b8152600401610832906128e9565b6012805460ff19811660ff90911615179055565b6012546301000000900460ff1681565b610eae6115d4565b6001600160a01b0316610ebf610f9b565b6001600160a01b031614610ee55760405162461bcd60e51b8152600401610832906128e9565b6064811115610f065760405162461bcd60e51b8152600401610832906129e7565b6000815b80821015610f87576001600c6000868686818110610f3857634e487b7160e01b600052603260045260246000fd5b9050602002016020810190610f4d9190611f27565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905581610f7f81612c84565b925050610f0a565b50505050565b601254610100900460ff1681565b6009546001600160a01b031690565b60606001805461078790612c49565b60105481565b610fc76115d4565b6001600160a01b0316610fd8610f9b565b6001600160a01b031614610ffe5760405162461bcd60e51b8152600401610832906128e9565b600f548114156110205760405162461bcd60e51b815260040161083290612b7a565b600f55565b601254610100900460ff1661104c5760405162461bcd60e51b81526004016108329061238f565b6000811161106c5760405162461bcd60e51b815260040161083290612b0c565b60125460ff16156110c157600c6000611083611542565b6001600160a01b0316815260208101919091526040016000205460ff1615156001146110c15760405162461bcd60e51b815260040161083290612546565b6010548111156110e35760405162461bcd60e51b81526004016108329061295f565b806011546110f19190612be7565b341461110f5760405162461bcd60e51b815260040161083290612a5f565b60005b8181101561118f576000611126600a611705565b9050611132600a611539565b61114361113d611542565b82611912565b600d600061114f611542565b6001600160a01b031681526020810191909152604001600090812080549161117683612c84565b9190505550818061118690612c84565b92505050611112565b600e54156111c057600e546111a2610a8c565b11156111c05760405162461bcd60e51b8152600401610832906123c6565b600f5415610bc457600f54600d60006111d7611542565b6001600160a01b03166001600160a01b03168152602001908152602001600020541115610bc45760405162461bcd60e51b8152600401610832906129a1565b610bc46112216115d4565b838361192c565b6112306115d4565b6001600160a01b0316611241610f9b565b6001600160a01b0316146112675760405162461bcd60e51b8152600401610832906128e9565b6012805462ff0000198116620100009182900460ff1615909102179055565b6112976112916115d4565b83611709565b6112b35760405162461bcd60e51b815260040161083290612abb565b610f87848484846119cf565b6001600160a01b03166000908152600c602052604090205460ff1690565b60606112e7611317565b6112f083611a02565b604051602001611301929190612256565b6040516020818303038152906040529050919050565b6060604051806060016040528060268152602001612d6460269139905090565b60125460ff1681565b600b5460405163c455279160e01b81526000916001600160a01b039081169190841690829063c4552791906113799088906004016122a0565b60206040518083038186803b15801561139157600080fd5b505afa1580156113a5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113c991906121a3565b6001600160a01b031614156113e25760019150506113f0565b6113ec8484611b25565b9150505b92915050565b600f5481565b6114046115d4565b6001600160a01b0316611415610f9b565b6001600160a01b03161461143b5760405162461bcd60e51b8152600401610832906128e9565b6001600160a01b0381166114615760405162461bcd60e51b81526004016108329061244d565b61146a816118c0565b50565b6114756115d4565b6001600160a01b0316611486610f9b565b6001600160a01b0316146114ac5760405162461bcd60e51b8152600401610832906128e9565b6011548114156114ce5760405162461bcd60e51b815260040161083290612b43565b601155565b6114db6115d4565b6001600160a01b03166114ec610f9b565b6001600160a01b0316146115125760405162461bcd60e51b8152600401610832906128e9565b6010548114156115345760405162461bcd60e51b8152600401610832906127fe565b601055565b80546001019055565b60003330141561159957600080368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b031691506108089050565b503390565b6001600160e01b031981166301ffc9a760e01b14919050565b6000908152600260205260409020546001600160a01b0316151590565b6000610aa4611542565b600081815260046020526040902080546001600160a01b0319166001600160a01b038416908117909155819061161382610cc2565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60006001600160a01b0386166116745760405162461bcd60e51b815260040161083290612687565b600161168761168287611b53565b611bb1565b838686604051600081526020016040526040516116a7949392919061235e565b6020604051602081039080840390855afa1580156116c9573d6000803e3d6000fd5b505050602060405103516001600160a01b0316866001600160a01b031614905095945050505050565b60006116fe8284612bbb565b9392505050565b5490565b6000611714826115b7565b6117305760405162461bcd60e51b8152600401610832906125f8565b600061173b83610cc2565b9050806001600160a01b0316846001600160a01b0316148061176257506117628185611340565b806113ec5750836001600160a01b031661177b8461080b565b6001600160a01b031614949350505050565b826001600160a01b03166117a082610cc2565b6001600160a01b0316146117c65760405162461bcd60e51b8152600401610832906124ca565b6001600160a01b0382166117ec5760405162461bcd60e51b81526004016108329061257d565b6117f78383836108ea565b6118026000826115de565b6001600160a01b038316600090815260036020526040812080546001929061182b908490612c06565b90915550506001600160a01b0382166000908152600360205260408120805460019290611859908490612bbb565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a46108ea838383611bcd565b600980546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610bc4828260405180602001604052806000815250611c5c565b816001600160a01b0316836001600160a01b0316141561195e5760405162461bcd60e51b8152600401610832906125c1565b6001600160a01b0383811660008181526005602090815260408083209487168084529490915290819020805460ff1916851515179055517f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31906119c2908590612326565b60405180910390a3505050565b6119da84848461178d565b6119e684848484611c8f565b610f875760405162461bcd60e51b8152600401610832906123fb565b606081611a2757506040805180820190915260018152600360fc1b602082015261076d565b8160005b8115611a515780611a3b81612c84565b9150611a4a9050600a83612bd3565b9150611a2b565b60008167ffffffffffffffff811115611a7a57634e487b7160e01b600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015611aa4576020820181803683370190505b5090505b8415611b1d57611ab9600183612c06565b9150611ac6600a86612c9f565b611ad1906030612bbb565b60f81b818381518110611af457634e487b7160e01b600052603260045260246000fd5b60200101906001600160f81b031916908160001a905350611b16600a86612bd3565b9450611aa8565b949350505050565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b6000604051806080016040528060438152602001612d216043913980516020918201208351848301516040808701518051908601209051611b94950161233a565b604051602081830303815290604052805190602001209050919050565b6000611bbb610aa9565b82604051602001611b94929190612285565b6012546301000000900460ff161580611bf3575060125460ff6101009091041615156001145b611c0f5760405162461bcd60e51b815260040161083290612833565b60125462010000900460ff1615156001148015611c2d5750600f5415155b156108ea57600f54611c3e83610cf7565b11156108ea5760405162461bcd60e51b8152600401610832906127bb565b611c668383611daa565b611c736000848484611c8f565b6108ea5760405162461bcd60e51b8152600401610832906123fb565b6000611ca3846001600160a01b0316611e91565b15611d9f57836001600160a01b031663150b7a02611cbf6115d4565b8786866040518563ffffffff1660e01b8152600401611ce194939291906122e9565b602060405180830381600087803b158015611cfb57600080fd5b505af1925050508015611d2b575060408051601f3d908101601f19168201909252611d2891810190612187565b60015b611d85573d808015611d59576040519150601f19603f3d011682016040523d82523d6000602084013e611d5e565b606091505b508051611d7d5760405162461bcd60e51b8152600401610832906123fb565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611b1d565b506001949350505050565b6001600160a01b038216611dd05760405162461bcd60e51b815260040161083290612868565b611dd9816115b7565b15611df65760405162461bcd60e51b81526004016108329061250f565b611e02600083836108ea565b6001600160a01b0382166000908152600360205260408120805460019290611e2b908490612bbb565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4610bc460008383611bcd565b6001600160a01b03163b151590565b600082601f830112611eb0578081fd5b813567ffffffffffffffff80821115611ecb57611ecb612cdf565b604051601f8301601f19908116603f01168101908282118183101715611ef357611ef3612cdf565b81604052838152866020858801011115611f0b578485fd5b8360208701602083013792830160200193909352509392505050565b600060208284031215611f38578081fd5b81356116fe81612cf5565b60008060408385031215611f55578081fd5b8235611f6081612cf5565b91506020830135611f7081612cf5565b809150509250929050565b600080600060608486031215611f8f578081fd5b8335611f9a81612cf5565b92506020840135611faa81612cf5565b929592945050506040919091013590565b60008060008060808587031215611fd0578081fd5b8435611fdb81612cf5565b93506020850135611feb81612cf5565b925060408501359150606085013567ffffffffffffffff81111561200d578182fd5b61201987828801611ea0565b91505092959194509250565b60008060408385031215612037578182fd5b823561204281612cf5565b915060208301358015158114611f70578182fd5b600080600080600060a0868803121561206d578081fd5b853561207881612cf5565b9450602086013567ffffffffffffffff811115612093578182fd5b61209f88828901611ea0565b9450506040860135925060608601359150608086013560ff811681146120c3578182fd5b809150509295509295909350565b600080604083850312156120e3578182fd5b82356120ee81612cf5565b946020939093013593505050565b6000806020838503121561210e578182fd5b823567ffffffffffffffff80821115612125578384fd5b818501915085601f830112612138578384fd5b813581811115612146578485fd5b8660208083028501011115612159578485fd5b60209290920196919550909350505050565b60006020828403121561217c578081fd5b81356116fe81612d0a565b600060208284031215612198578081fd5b81516116fe81612d0a565b6000602082840312156121b4578081fd5b81516116fe81612cf5565b6000602082840312156121d0578081fd5b5035919050565b600081518084526121ef816020860160208601612c1d565b601f01601f19169290920160200192915050565b60008251612215818460208701612c1d565b9190910192915050565b60008351612231818460208801612c1d565b60609390931b6bffffffffffffffffffffffff19169190920190815260140192915050565b60008351612268818460208801612c1d565b83519083019061227c818360208801612c1d565b01949350505050565b61190160f01b81526002810192909252602282015260420190565b6001600160a01b0391909116815260200190565b6001600160a01b038481168252831660208201526060604082018190526000906122e0908301846121d7565b95945050505050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061231c908301846121d7565b9695505050505050565b901515815260200190565b90815260200190565b93845260208401929092526001600160a01b03166040830152606082015260800190565b93845260ff9290921660208401526040830152606082015260800190565b6000602082526116fe60208301846121d7565b60208082526017908201527f444547454e3a206d696e74696e672064697361626c6564000000000000000000604082015260600190565b6020808252818101527f444547454e3a20746f74616c206d696e74206c696d6974206578636565646564604082015260600190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b6020808252601c908201527f46756e6374696f6e2063616c6c206e6f74207375636365737366756c00000000604082015260600190565b60208082526025908201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060408201526437bbb732b960d91b606082015260800190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b6020808252601a908201527f444547454e3a206d7573742062652077686974656c6973746564000000000000604082015260600190565b60208082526024908201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646040820152637265737360e01b606082015260800190565b60208082526019908201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604082015260600190565b6020808252602c908201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b60208082526023908201527f444547454e3a2063616e6e6f74207365742073616d6520737570706c79206c696040820152621b5a5d60ea1b606082015260800190565b60208082526025908201527f4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f5360408201526424a3a722a960d91b606082015260800190565b60208082526029908201527f4552433732313a2061646472657373207a65726f206973206e6f7420612076616040820152683634b21037bbb732b960b91b606082015260800190565b60208082526038908201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760408201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606082015260800190565b60208082526029908201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460408201526832b73a103a37b5b2b760b91b606082015260800190565b60208082526023908201527f444547454e3a206163636f756e7420746f6b656e206c696d697420657863656560408201526219195960ea1b606082015260800190565b6020808252818101527f444547454e3a2063616e6e6f74207365742073616d652074786e206c696d6974604082015260600190565b6020808252818101527f444547454e3a206e6f207472616e736665727320617420746869732074696d65604082015260600190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b6020808252602c908201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526021908201527f5369676e657220616e64207369676e617475726520646f206e6f74206d6174636040820152600d60fb1b606082015260800190565b60208082526022908201527f444547454e3a207065722074786e206d696e74206c696d697420657863656564604082015261195960f21b606082015260800190565b60208082526026908201527f444547454e3a20706572206163636f756e74206d696e74206c696d697420657860408201526518d95959195960d21b606082015260800190565b6020808252601a908201527f444547454e3a206c696d69742031303020616464726573736573000000000000604082015260600190565b60208082526021908201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656040820152603960f91b606082015260800190565b602080825260129082015271444547454e3a2077726f6e672076616c756560701b604082015260600190565b602080825260169082015275111151d1538e881dda5d1a191c985dc819985a5b195960521b604082015260600190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252601b908201527f444547454e3a2063616e6e6f74206d696e74203020746f6b656e730000000000604082015260600190565b6020808252601c908201527f444547454e3a2063616e6e6f74207365742073616d6520707269636500000000604082015260600190565b60208082526021908201527f444547454e3a2063616e6e6f74207365742073616d65206d696e74206c696d696040820152601d60fa1b606082015260800190565b60008219821115612bce57612bce612cb3565b500190565b600082612be257612be2612cc9565b500490565b6000816000190483118215151615612c0157612c01612cb3565b500290565b600082821015612c1857612c18612cb3565b500390565b60005b83811015612c38578181015183820152602001612c20565b83811115610f875750506000910152565b600281046001821680612c5d57607f821691505b60208210811415612c7e57634e487b7160e01b600052602260045260246000fd5b50919050565b6000600019821415612c9857612c98612cb3565b5060010190565b600082612cae57612cae612cc9565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b038116811461146a57600080fd5b6001600160e01b03198116811461146a57600080fdfe4d6574615472616e73616374696f6e2875696e74323536206e6f6e63652c616464726573732066726f6d2c62797465732066756e6374696f6e5369676e61747572652968747470733a2f2f646567656e2e6d656761776561706f6e2e696f2f646567656e2f7330312fa2646970667358221220dca3278421222ada84b75ee6113591b2cfc700daa50cee8cb3a5672bb28a2c8f64736f6c63430008010033454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c6164647265737320766572696679696e67436f6e74726163742c627974657333322073616c7429

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

61:3903:19:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1556:305:6;;;;;;;;;;-1:-1:-1;1556:305:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;349:37:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;2500:100:6:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4060:221::-;;;;;;;;;;-1:-1:-1;4060:221:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3583:411::-;;;;;;;;;;-1:-1:-1;3583:411:6;;;;;:::i;:::-;;:::i;:::-;;975:1151:15;;;;;;:::i;:::-;;:::i;302:43:4:-;;;;;;;;;;;;;:::i;2124:105:8:-;;;;;;;;;;;;;:::i;1311:101:4:-;;;;;;;;;;;;;:::i;4810:339:6:-;;;;;;;;;;-1:-1:-1;4810:339:6;;;;;:::i;:::-;;:::i;2552:107:15:-;;;;;;;;;;-1:-1:-1;2552:107:15;;;;;:::i;:::-;;:::i;3397:172:19:-;;;;;;;;;;-1:-1:-1;3397:172:19;;;;;:::i;:::-;;:::i;1420:161:4:-;;;;;;;;;;;;;:::i;2451:175:19:-;;;;;;;;;;-1:-1:-1;2451:175:19;;;;;:::i;:::-;;:::i;3294:95::-;;;;;;;;;;;;;:::i;5220:185:6:-;;;;;;;;;;-1:-1:-1;5220:185:6;;;;;:::i;:::-;;:::i;475:33:19:-;;;;;;;;;;;;;:::i;253:24::-;;;;;;;;;;;;;:::i;2194:239:6:-;;;;;;;;;;-1:-1:-1;2194:239:6;;;;;:::i;:::-;;:::i;1925:207::-;;;;;;;;;;-1:-1:-1;1925:207:6;;;;;:::i;:::-;;:::i;1714:103:16:-;;;;;;;;;;;;;:::i;1763:188:8:-;;;;;;;;;;-1:-1:-1;1763:188:8;;;;;:::i;:::-;;:::i;3080:97:19:-;;;;;;;;;;;;;:::i;2975:::-;;;;;;;;;;;;;:::i;515:32::-;;;;;;;;;;;;;:::i;1828:316::-;;;;;;;;;;-1:-1:-1;1828:316:19;;;;;:::i;:::-;;:::i;433:35::-;;;;;;;;;;;;;:::i;1063:87:16:-;;;;;;;;;;;;;:::i;2669:104:6:-;;;;;;;;;;;;;:::i;317:25:19:-;;;;;;;;;;;;;:::i;2272:167::-;;;;;;;;;;-1:-1:-1;2272:167:19;;;;;:::i;:::-;;:::i;821:999::-;;;;;;:::i;:::-;;:::i;4353:155:6:-;;;;;;;;;;-1:-1:-1;4353:155:6;;;;;:::i;:::-;;:::i;3185:101:19:-;;;;;;;;;;;;;:::i;5476:326:6:-;;;;;;;;;;-1:-1:-1;5476:326:6;;;;;:::i;:::-;;:::i;2152:112:19:-;;;;;;;;;;-1:-1:-1;2152:112:19;;;;;:::i;:::-;;:::i;2313:175:8:-;;;;;;;;;;-1:-1:-1;2313:175:8;;;;;:::i;:::-;;:::i;678:135:19:-;;;;;;;;;;;;;:::i;393:33::-;;;;;;;;;;;;;:::i;2620:445:8:-;;;;;;;;;;-1:-1:-1;2620:445:8;;;;;:::i;:::-;;:::i;284:26:19:-;;;;;;;;;;;;;:::i;1972:201:16:-;;;;;;;;;;-1:-1:-1;1972:201:16;;;;;:::i;:::-;;:::i;2805:162:19:-;;;;;;;;;;-1:-1:-1;2805:162:19;;;;;:::i;:::-;;:::i;2634:163::-;;;;;;;;;;-1:-1:-1;2634:163:19;;;;;:::i;:::-;;:::i;1556:305:6:-;1658:4;-1:-1:-1;;;;;;1695:40:6;;-1:-1:-1;;;1695:40:6;;:105;;-1:-1:-1;;;;;;;1752:48:6;;-1:-1:-1;;;1752:48:6;1695:105;:158;;;;1817:36;1841:11;1817:23;:36::i;:::-;1675:178;;1556:305;;;;:::o;349:37:19:-;;;;:::o;2500:100:6:-;2554:13;2587:5;2580:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2500:100;;:::o;4060:221::-;4136:7;4164:16;4172:7;4164;:16::i;:::-;4156:73;;;;-1:-1:-1;;;4156:73:6;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;4249:24:6;;;;:15;:24;;;;;;-1:-1:-1;;;;;4249:24:6;;4060:221::o;3583:411::-;3664:13;3680:23;3695:7;3680:14;:23::i;:::-;3664:39;;3728:5;-1:-1:-1;;;;;3722:11:6;:2;-1:-1:-1;;;;;3722:11:6;;;3714:57;;;;-1:-1:-1;;;3714:57:6;;;;;;;:::i;:::-;3822:5;-1:-1:-1;;;;;3806:21:6;:12;:10;:12::i;:::-;-1:-1:-1;;;;;3806:21:6;;:62;;;;3831:37;3848:5;3855:12;:10;:12::i;3831:37::-;3784:168;;;;-1:-1:-1;;;3784:168:6;;;;;;;:::i;:::-;3965:21;3974:2;3978:7;3965:8;:21::i;:::-;3583:411;;;:::o;975:1151:15:-;1233:152;;;1176:12;1233:152;;;;;-1:-1:-1;;;;;1271:19:15;;1201:29;1271:19;;;:6;:19;;;;;;;;;1233:152;;;;;;;;;;;1420:45;1278:11;1233:152;1448:4;1454;1460;1420:6;:45::i;:::-;1398:128;;;;-1:-1:-1;;;1398:128:15;;;;;;;:::i;:::-;-1:-1:-1;;;;;1615:19:15;;;;;;:6;:19;;;;;;:26;;1639:1;1615:23;:26::i;:::-;-1:-1:-1;;;;;1593:19:15;;;;;;:6;:19;;;;;;;:48;;;;1659:126;;;;;1600:11;;1731:10;;1757:17;;1659:126;:::i;:::-;;;;;;;;1896:12;1910:23;1945:4;-1:-1:-1;;;;;1937:18:15;1987:17;2006:11;1970:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1970:48:15;;;;;;;;;;1937:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1895:134;;;;2048:7;2040:48;;;;-1:-1:-1;;;2040:48:15;;;;;;;:::i;:::-;2108:10;975:1151;-1:-1:-1;;;;;;;;975:1151:15:o;302:43:4:-;;;;;;;;;;;;;;-1:-1:-1;;;302:43:4;;;;:::o;2124:105:8:-;2168:7;2220:1;2195:22;:12;:20;:22::i;:::-;:26;;;;:::i;:::-;2188:33;;2124:105;:::o;1311:101:4:-;1389:15;;1311:101;:::o;4810:339:6:-;5005:41;5024:12;:10;:12::i;:::-;5038:7;5005:18;:41::i;:::-;4997:103;;;;-1:-1:-1;;;4997:103:6;;;;;;;:::i;:::-;5113:28;5123:4;5129:2;5133:7;5113:9;:28::i;2552:107:15:-;-1:-1:-1;;;;;2639:12:15;2605:13;2639:12;;;:6;:12;;;;;;;2552:107::o;3397:172:19:-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;3459:9:19::1;3474:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;3474:17:19::1;3499:6;3474:36;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3458:52;;;3530:4;3521:40;;;;-1:-1:-1::0;;;3521:40:19::1;;;;;;;:::i;:::-;1354:1:16;3397:172:19::0;:::o;1420:161:4:-;1534:9;1420:161;:::o;2451:175:19:-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;2535:12:19::1;;2526:5;:21;;2517:70;;;;-1:-1:-1::0;;;2517:70:19::1;;;;;;;:::i;:::-;2598:12;:20:::0;2451:175::o;3294:95::-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;3369:12:19::1;::::0;;-1:-1:-1;;3353:28:19;::::1;3369:12:::0;;;;::::1;;;3368:13;3353:28:::0;;::::1;;::::0;;3294:95::o;5220:185:6:-;5358:39;5375:4;5381:2;5385:7;5358:39;;;;;;;;;;;;:16;:39::i;475:33:19:-;;;;;;;;;:::o;253:24::-;;;;:::o;2194:239:6:-;2266:7;2302:16;;;:7;:16;;;;;;-1:-1:-1;;;;;2302:16:6;2337:19;2329:73;;;;-1:-1:-1;;;2329:73:6;;;;;;;:::i;1925:207::-;1997:7;-1:-1:-1;;;;;2025:19:6;;2017:73;;;;-1:-1:-1;;;2017:73:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;;2108:16:6;;;;;:9;:16;;;;;;;1925:207::o;1714:103:16:-;1294:12;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1779:30:::1;1806:1;1779:18;:30::i;:::-;1714:103::o:0;1763:188:8:-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1820:22:8::1;1845;:12;:20;:22::i;:::-;1820:47;;1878:24;:12;:22;:24::i;:::-;1913:30;1923:3;1928:14;1913:9;:30::i;3080:97:19:-:0;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;3154:15:19::1;::::0;;-1:-1:-1;;3135:34:19;::::1;3154:15;::::0;;;::::1;;;3153:16;3135:34:::0;;::::1;;::::0;;3080:97::o;2975:::-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;3050:14:19::1;::::0;;-1:-1:-1;;3032:32:19;::::1;3050:14;::::0;;::::1;3049:15;3032:32;::::0;;2975:97::o;515:32::-;;;;;;;;;:::o;1828:316::-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1941:3:19::1;1921:23:::0;::::1;;1912:63;;;;-1:-1:-1::0;;;1912:63:19::1;;;;;;;:::i;:::-;1986:6;2018:9:::0;2045:92:::1;2056:3;2052:1;:7;2045:92;;;2103:4;2076:10;:24;2087:9;;2097:1;2087:12;;;;;-1:-1:-1::0;;;2087:12:19::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;2076:24:19::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;2076:24:19;:31;;-1:-1:-1;;2076:31:19::1;::::0;::::1;;::::0;;;::::1;::::0;;2122:3;::::1;::::0;::::1;:::i;:::-;;;;2045:92;;;1354:1:16;;1828:316:19::0;;:::o;433:35::-;;;;;;;;;:::o;1063:87:16:-;1136:6;;-1:-1:-1;;;;;1136:6:16;1063:87;:::o;2669:104:6:-;2725:13;2758:7;2751:14;;;;;:::i;317:25:19:-;;;;:::o;2272:167::-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;2354:10:19::1;;2345:5;:19;;2336:66;;;;-1:-1:-1::0;;;2336:66:19::1;;;;;;;:::i;:::-;2413:10;:18:::0;2272:167::o;821:999::-;889:15;;;;;;;880:52;;;;-1:-1:-1;;;880:52:19;;;;;;;:::i;:::-;965:1;952:10;:14;943:55;;;;-1:-1:-1;;;943:55:19;;;;;;;:::i;:::-;1013:14;;;;1009:104;;;1051:10;:23;1062:11;:9;:11::i;:::-;-1:-1:-1;;;;;1051:23:19;;;;;;;;;;;;-1:-1:-1;1051:23:19;;;;:31;;:23;:31;1042:71;;;;-1:-1:-1;;;1042:71:19;;;;;;;:::i;:::-;1147:9;;1133:10;:23;;1124:71;;;;-1:-1:-1;;;1124:71:19;;;;;;;:::i;:::-;1242:10;1229;;:23;;;;:::i;:::-;1215:9;:38;1206:70;;;;-1:-1:-1;;;1206:70:19;;;;;;;:::i;:::-;1287:6;1308:247;1319:10;1315:1;:14;1308:247;;;1346:22;1371;:12;:20;:22::i;:::-;1346:47;;1408:24;:12;:22;:24::i;:::-;1447:38;1457:11;:9;:11::i;:::-;1470:14;1447:9;:38::i;:::-;1500:10;:23;1511:11;:9;:11::i;:::-;-1:-1:-1;;;;;1500:23:19;;;;;;;;;;;;-1:-1:-1;1500:23:19;;;:25;;;;;;:::i;:::-;;;;;;1540:3;;;;;:::i;:::-;;;;1308:247;;;;1569:12;;:17;1565:112;;1628:12;;1611:13;:11;:13::i;:::-;:29;;1602:75;;;;-1:-1:-1;;;1602:75:19;;;;;;;:::i;:::-;1692:10;;:15;1688:124;;1759:10;;1732;:23;1743:11;:9;:11::i;:::-;-1:-1:-1;;;;;1732:23:19;-1:-1:-1;;;;;1732:23:19;;;;;;;;;;;;;:37;;1723:89;;;;-1:-1:-1;;;1723:89:19;;;;;;;:::i;4353:155:6:-;4448:52;4467:12;:10;:12::i;:::-;4481:8;4491;4448:18;:52::i;3185:101:19:-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;3264:14:19::1;::::0;;-1:-1:-1;;3246:32:19;::::1;3264:14:::0;;;;::::1;;;3263:15;3246:32:::0;;::::1;;::::0;;3185:101::o;5476:326:6:-;5650:41;5669:12;:10;:12::i;:::-;5683:7;5650:18;:41::i;:::-;5642:103;;;;-1:-1:-1;;;5642:103:6;;;;;;;:::i;:::-;5756:38;5770:4;5776:2;5780:7;5789:4;5756:13;:38::i;2152:112:19:-;-1:-1:-1;;;;;2237:19:19;2213:4;2237:19;;;:10;:19;;;;;;;;;2152:112::o;2313:175:8:-;2379:13;2436:14;:12;:14::i;:::-;2452:26;2469:8;2452:16;:26::i;:::-;2419:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2405:75;;2313:175;;;:::o;678:135:19:-;732:13;758:47;;;;;;;;;;;;;;;;;;;678:135;:::o;393:33::-;;;;;;:::o;2620:445:8:-;2874:20;;2918:28;;-1:-1:-1;;;2918:28:8;;2745:4;;-1:-1:-1;;;;;2874:20:8;;;;2910:49;;;;2874:20;;2918:21;;:28;;2940:5;;2918:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;2910:49:8;;2906:93;;;2983:4;2976:11;;;;;2906:93;3018:39;3041:5;3048:8;3018:22;:39::i;:::-;3011:46;;;2620:445;;;;;:::o;284:26:19:-;;;;:::o;1972:201:16:-;1294:12;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;-1:-1:-1;;;;;2061:22:16;::::1;2053:73;;;;-1:-1:-1::0;;;2053:73:16::1;;;;;;;:::i;:::-;2137:28;2156:8;2137:18;:28::i;:::-;1972:201:::0;:::o;2805:162:19:-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;2887:10:19::1;;2878:5;:19;;2869:61;;;;-1:-1:-1::0;;;2869:61:19::1;;;;;;;:::i;:::-;2941:10;:18:::0;2805:162::o;2634:163::-;1294:12:16;:10;:12::i;:::-;-1:-1:-1;;;;;1283:23:16;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1283:23:16;;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;2715:9:19::1;;2706:5;:18;;2697:64;;;;-1:-1:-1::0;;;2697:64:19::1;;;;;;;:::i;:::-;2772:9;:17:::0;2634:163::o;970:127:3:-;1059:19;;1077:1;1059:19;;;970:127::o;100:650:1:-;171:22;215:10;237:4;215:27;211:508;;;259:18;280:8;;259:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;319:8:1;530:17;524:24;-1:-1:-1;;;;;498:134:1;;-1:-1:-1;358:289:1;;-1:-1:-1;358:289:1;;-1:-1:-1;696:10:1;100:650;:::o;854:157:5:-;-1:-1:-1;;;;;;963:40:5;;-1:-1:-1;;;963:40:5;854:157;;;:::o;7309:127:6:-;7374:4;7398:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7398:16:6;:30;;;7309:127::o;3209:161:8:-;3299:14;3338:24;:22;:24::i;11453:174:6:-;11528:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;11528:29:6;-1:-1:-1;;;;;11528:29:6;;;;;;;;:24;;11582:23;11528:24;11582:14;:23::i;:::-;-1:-1:-1;;;;;11573:46:6;;;;;;;;;;;11453:174;;:::o;2667:486:15:-;2845:4;-1:-1:-1;;;;;2870:20:15;;2862:70;;;;-1:-1:-1;;;2862:70:15;;;;;;;:::i;:::-;2986:159;3014:47;3033:27;3053:6;3033:19;:27::i;:::-;3014:18;:47::i;:::-;3080:4;3103;3126;2986:159;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2963:182:15;:6;-1:-1:-1;;;;;2963:182:15;;2943:202;;2667:486;;;;;;;:::o;2847:98:17:-;2905:7;2932:5;2936:1;2932;:5;:::i;:::-;2925:12;2847:98;-1:-1:-1;;;2847:98:17:o;848:114:3:-;940:14;;848:114::o;7603:348:6:-;7696:4;7721:16;7729:7;7721;:16::i;:::-;7713:73;;;;-1:-1:-1;;;7713:73:6;;;;;;;:::i;:::-;7797:13;7813:23;7828:7;7813:14;:23::i;:::-;7797:39;;7866:5;-1:-1:-1;;;;;7855:16:6;:7;-1:-1:-1;;;;;7855:16:6;;:52;;;;7875:32;7892:5;7899:7;7875:16;:32::i;:::-;7855:87;;;;7935:7;-1:-1:-1;;;;;7911:31:6;:20;7923:7;7911:11;:20::i;:::-;-1:-1:-1;;;;;7911:31:6;;;7603:348;-1:-1:-1;;;;7603:348:6:o;10710:625::-;10869:4;-1:-1:-1;;;;;10842:31:6;:23;10857:7;10842:14;:23::i;:::-;-1:-1:-1;;;;;10842:31:6;;10834:81;;;;-1:-1:-1;;;10834:81:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;10934:16:6;;10926:65;;;;-1:-1:-1;;;10926:65:6;;;;;;;:::i;:::-;11004:39;11025:4;11031:2;11035:7;11004:20;:39::i;:::-;11108:29;11125:1;11129:7;11108:8;:29::i;:::-;-1:-1:-1;;;;;11150:15:6;;;;;;:9;:15;;;;;:20;;11169:1;;11150:15;:20;;11169:1;;11150:20;:::i;:::-;;;;-1:-1:-1;;;;;;;11181:13:6;;;;;;:9;:13;;;;;:18;;11198:1;;11181:13;:18;;11198:1;;11181:18;:::i;:::-;;;;-1:-1:-1;;11210:16:6;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;11210:21:6;-1:-1:-1;;;;;11210:21:6;;;;;;;;;11249:27;;11210:16;;11249:27;;;;;;;11289:38;11309:4;11315:2;11319:7;11289:19;:38::i;2333:191:16:-;2426:6;;;-1:-1:-1;;;;;2443:17:16;;;-1:-1:-1;;;;;;2443:17:16;;;;;;;2476:40;;2426:6;;;2443:17;2426:6;;2476:40;;2407:16;;2476:40;2333:191;;:::o;8293:110:6:-;8369:26;8379:2;8383:7;8369:26;;;;;;;;;;;;:9;:26::i;11769:315::-;11924:8;-1:-1:-1;;;;;11915:17:6;:5;-1:-1:-1;;;;;11915:17:6;;;11907:55;;;;-1:-1:-1;;;11907:55:6;;;;;;;:::i;:::-;-1:-1:-1;;;;;11973:25:6;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;:46;;-1:-1:-1;;11973:46:6;;;;;;;12035:41;;;;;11973:46;;12035:41;:::i;:::-;;;;;;;;11769:315;;;:::o;6683:313::-;6839:28;6849:4;6855:2;6859:7;6839:9;:28::i;:::-;6886:47;6909:4;6915:2;6919:7;6928:4;6886:22;:47::i;:::-;6878:110;;;;-1:-1:-1;;;6878:110:6;;;;;;;:::i;342:723:18:-;398:13;619:10;615:53;;-1:-1:-1;646:10:18;;;;;;;;;;;;-1:-1:-1;;;646:10:18;;;;;;615:53;693:5;678:12;734:78;741:9;;734:78;;767:8;;;;:::i;:::-;;-1:-1:-1;790:10:18;;-1:-1:-1;798:2:18;790:10;;:::i;:::-;;;734:78;;;822:19;854:6;844:17;;;;;;-1:-1:-1;;;844:17:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;844:17:18;;822:39;;872:154;879:10;;872:154;;906:11;916:1;906:11;;:::i;:::-;;-1:-1:-1;975:10:18;983:2;975:5;:10;:::i;:::-;962:24;;:2;:24;:::i;:::-;949:39;;932:6;939;932:14;;;;;;-1:-1:-1;;;932:14:18;;;;;;;;;;;;:56;-1:-1:-1;;;;;932:56:18;;;;;;;;-1:-1:-1;1003:11:18;1012:2;1003:11;;:::i;:::-;;;872:154;;;1050:6;342:723;-1:-1:-1;;;;342:723:18:o;4579:164:6:-;-1:-1:-1;;;;;4700:25:6;;;4676:4;4700:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4579:164::o;2134:410:15:-;2244:7;311:100;;;;;;;;;;;;;;;;;291:127;;;;;;;2398:12;;2433:11;;;;2477:24;;;;;2467:35;;;;;;2317:204;;;;;;:::i;:::-;;;;;;;;;;;;;2289:247;;;;;;2269:267;;2134:410;;;:::o;1950:258:4:-;2049:7;2151:20;:18;:20::i;:::-;2173:11;2122:63;;;;;;;;;:::i;3577:384:19:-;3721:12;;;;;;;:21;;:48;;-1:-1:-1;3746:15:19;;;;;;;;:23;;:15;:23;3721:48;3712:94;;;;-1:-1:-1;;;3712:94:19;;;;;;;:::i;:::-;3821:14;;;;;;;:22;;3839:4;3821:22;:41;;;;-1:-1:-1;3847:10:19;;:15;;3821:41;3817:136;;;3903:10;;3886:13;3896:2;3886:9;:13::i;:::-;:27;;3877:76;;;;-1:-1:-1;;;3877:76:19;;;;;;;:::i;8630:319:6:-;8759:18;8765:2;8769:7;8759:5;:18::i;:::-;8810:53;8841:1;8845:2;8849:7;8858:4;8810:22;:53::i;:::-;8788:153;;;;-1:-1:-1;;;8788:153:6;;;;;;;:::i;12648:797::-;12802:4;12823:15;:2;-1:-1:-1;;;;;12823:13:6;;:15::i;:::-;12819:619;;;12875:2;-1:-1:-1;;;;;12859:36:6;;12896:12;:10;:12::i;:::-;12910:4;12916:7;12925:4;12859:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12859:71:6;;;;;;;;-1:-1:-1;;12859:71:6;;;;;;;;;;;;:::i;:::-;;;12855:528;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13100:13:6;;13096:272;;13143:60;;-1:-1:-1;;;13143:60:6;;;;;;;:::i;13096:272::-;13318:6;13312:13;13303:6;13299:2;13295:15;13288:38;12855:528;-1:-1:-1;;;;;;12981:51:6;-1:-1:-1;;;12981:51:6;;-1:-1:-1;12974:58:6;;12819:619;-1:-1:-1;13422:4:6;12648:797;;;;;;:::o;9285:439::-;-1:-1:-1;;;;;9365:16:6;;9357:61;;;;-1:-1:-1;;;9357:61:6;;;;;;;:::i;:::-;9438:16;9446:7;9438;:16::i;:::-;9437:17;9429:58;;;;-1:-1:-1;;;9429:58:6;;;;;;;:::i;:::-;9500:45;9529:1;9533:2;9537:7;9500:20;:45::i;:::-;-1:-1:-1;;;;;9558:13:6;;;;;;:9;:13;;;;;:18;;9575:1;;9558:13;:18;;9575:1;;9558:18;:::i;:::-;;;;-1:-1:-1;;9587:16:6;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9587:21:6;-1:-1:-1;;;;;9587:21:6;;;;;;;;9626:33;;9587:16;;;9626:33;;9587:16;;9626:33;9672:44;9700:1;9704:2;9708:7;9672:19;:44::i;1210:326:0:-;-1:-1:-1;;;;;1505:19:0;;:23;;;1210:326::o;14:740:20:-;;111:3;104:4;96:6;92:17;88:27;78:2;;133:5;126;119:20;78:2;173:6;160:20;199:18;236:2;232;229:10;226:2;;;242:18;;:::i;:::-;317:2;311:9;285:2;371:13;;-1:-1:-1;;367:22:20;;;391:2;363:31;359:40;347:53;;;415:18;;;435:22;;;412:46;409:2;;;461:18;;:::i;:::-;501:10;497:2;490:22;536:2;528:6;521:18;582:3;575:4;570:2;562:6;558:15;554:26;551:35;548:2;;;603:5;596;589:20;548:2;671;664:4;656:6;652:17;645:4;637:6;633:17;620:54;694:15;;;711:4;690:26;683:41;;;;-1:-1:-1;698:6:20;68:686;-1:-1:-1;;;68:686:20:o;759:259::-;;871:2;859:9;850:7;846:23;842:32;839:2;;;892:6;884;877:22;839:2;936:9;923:23;955:33;982:5;955:33;:::i;1023:402::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1217:9;1204:23;1236:33;1263:5;1236:33;:::i;:::-;1288:5;-1:-1:-1;1345:2:20;1330:18;;1317:32;1358:35;1317:32;1358:35;:::i;:::-;1412:7;1402:17;;;1110:315;;;;;:::o;1430:470::-;;;;1576:2;1564:9;1555:7;1551:23;1547:32;1544:2;;;1597:6;1589;1582:22;1544:2;1641:9;1628:23;1660:33;1687:5;1660:33;:::i;:::-;1712:5;-1:-1:-1;1769:2:20;1754:18;;1741:32;1782:35;1741:32;1782:35;:::i;:::-;1534:366;;1836:7;;-1:-1:-1;;;1890:2:20;1875:18;;;;1862:32;;1534:366::o;1905:691::-;;;;;2077:3;2065:9;2056:7;2052:23;2048:33;2045:2;;;2099:6;2091;2084:22;2045:2;2143:9;2130:23;2162:33;2189:5;2162:33;:::i;:::-;2214:5;-1:-1:-1;2271:2:20;2256:18;;2243:32;2284:35;2243:32;2284:35;:::i;:::-;2338:7;-1:-1:-1;2392:2:20;2377:18;;2364:32;;-1:-1:-1;2447:2:20;2432:18;;2419:32;2474:18;2463:30;;2460:2;;;2511:6;2503;2496:22;2460:2;2539:51;2582:7;2573:6;2562:9;2558:22;2539:51;:::i;:::-;2529:61;;;2035:561;;;;;;;:::o;2601:438::-;;;2727:2;2715:9;2706:7;2702:23;2698:32;2695:2;;;2748:6;2740;2733:22;2695:2;2792:9;2779:23;2811:33;2838:5;2811:33;:::i;:::-;2863:5;-1:-1:-1;2920:2:20;2905:18;;2892:32;2962:15;;2955:23;2943:36;;2933:2;;2998:6;2990;2983:22;3044:792;;;;;;3231:3;3219:9;3210:7;3206:23;3202:33;3199:2;;;3253:6;3245;3238:22;3199:2;3297:9;3284:23;3316:33;3343:5;3316:33;:::i;:::-;3368:5;-1:-1:-1;3424:2:20;3409:18;;3396:32;3451:18;3440:30;;3437:2;;;3488:6;3480;3473:22;3437:2;3516:51;3559:7;3550:6;3539:9;3535:22;3516:51;:::i;:::-;3506:61;;;3614:2;3603:9;3599:18;3586:32;3576:42;;3665:2;3654:9;3650:18;3637:32;3627:42;;3721:3;3710:9;3706:19;3693:33;3770:4;3761:7;3757:18;3748:7;3745:31;3735:2;;3795:6;3787;3780:22;3735:2;3823:7;3813:17;;;3189:647;;;;;;;;:::o;3841:327::-;;;3970:2;3958:9;3949:7;3945:23;3941:32;3938:2;;;3991:6;3983;3976:22;3938:2;4035:9;4022:23;4054:33;4081:5;4054:33;:::i;:::-;4106:5;4158:2;4143:18;;;;4130:32;;-1:-1:-1;;;3928:240:20:o;4173:666::-;;;4320:2;4308:9;4299:7;4295:23;4291:32;4288:2;;;4341:6;4333;4326:22;4288:2;4386:9;4373:23;4415:18;4456:2;4448:6;4445:14;4442:2;;;4477:6;4469;4462:22;4442:2;4520:6;4509:9;4505:22;4495:32;;4565:7;4558:4;4554:2;4550:13;4546:27;4536:2;;4592:6;4584;4577:22;4536:2;4637;4624:16;4663:2;4655:6;4652:14;4649:2;;;4684:6;4676;4669:22;4649:2;4743:7;4738:2;4732;4724:6;4720:15;4716:2;4712:24;4708:33;4705:46;4702:2;;;4769:6;4761;4754:22;4702:2;4805;4797:11;;;;;4827:6;;-1:-1:-1;4278:561:20;;-1:-1:-1;;;;4278:561:20:o;4844:257::-;;4955:2;4943:9;4934:7;4930:23;4926:32;4923:2;;;4976:6;4968;4961:22;4923:2;5020:9;5007:23;5039:32;5065:5;5039:32;:::i;5106:261::-;;5228:2;5216:9;5207:7;5203:23;5199:32;5196:2;;;5249:6;5241;5234:22;5196:2;5286:9;5280:16;5305:32;5331:5;5305:32;:::i;5372:292::-;;5524:2;5512:9;5503:7;5499:23;5495:32;5492:2;;;5545:6;5537;5530:22;5492:2;5582:9;5576:16;5601:33;5628:5;5601:33;:::i;5669:190::-;;5781:2;5769:9;5760:7;5756:23;5752:32;5749:2;;;5802:6;5794;5787:22;5749:2;-1:-1:-1;5830:23:20;;5739:120;-1:-1:-1;5739:120:20:o;5864:259::-;;5945:5;5939:12;5972:6;5967:3;5960:19;5988:63;6044:6;6037:4;6032:3;6028:14;6021:4;6014:5;6010:16;5988:63;:::i;:::-;6105:2;6084:15;-1:-1:-1;;6080:29:20;6071:39;;;;6112:4;6067:50;;5915:208;-1:-1:-1;;5915:208:20:o;6128:274::-;;6295:6;6289:13;6311:53;6357:6;6352:3;6345:4;6337:6;6333:17;6311:53;:::i;:::-;6380:16;;;;;6265:137;-1:-1:-1;;6265:137:20:o;6407:415::-;;6602:6;6596:13;6618:53;6664:6;6659:3;6652:4;6644:6;6640:17;6618:53;:::i;:::-;6740:2;6736:15;;;;-1:-1:-1;;6732:53:20;6693:16;;;;6718:68;;;6813:2;6802:14;;6572:250;-1:-1:-1;;6572:250:20:o;6827:470::-;;7044:6;7038:13;7060:53;7106:6;7101:3;7094:4;7086:6;7082:17;7060:53;:::i;:::-;7176:13;;7135:16;;;;7198:57;7176:13;7135:16;7232:4;7220:17;;7198:57;:::i;:::-;7271:20;;7014:283;-1:-1:-1;;;;7014:283:20:o;7302:392::-;-1:-1:-1;;;7560:27:20;;7612:1;7603:11;;7596:27;;;;7648:2;7639:12;;7632:28;7685:2;7676:12;;7550:144::o;7909:203::-;-1:-1:-1;;;;;8073:32:20;;;;8055:51;;8043:2;8028:18;;8010:102::o;8117:433::-;-1:-1:-1;;;;;8374:15:20;;;8356:34;;8426:15;;8421:2;8406:18;;8399:43;8478:2;8473;8458:18;;8451:30;;;8117:433;;8498:46;;8525:18;;8517:6;8498:46;:::i;:::-;8490:54;8308:242;-1:-1:-1;;;;;8308:242:20:o;8555:490::-;-1:-1:-1;;;;;8824:15:20;;;8806:34;;8876:15;;8871:2;8856:18;;8849:43;8923:2;8908:18;;8901:34;;;8971:3;8966:2;8951:18;;8944:31;;;8555:490;;8992:47;;9019:19;;9011:6;8992:47;:::i;:::-;8984:55;8758:287;-1:-1:-1;;;;;;8758:287:20:o;9050:187::-;9215:14;;9208:22;9190:41;;9178:2;9163:18;;9145:92::o;9242:177::-;9388:25;;;9376:2;9361:18;;9343:76::o;9424:417::-;9655:25;;;9711:2;9696:18;;9689:34;;;;-1:-1:-1;;;;;9759:32:20;9754:2;9739:18;;9732:60;9823:2;9808:18;;9801:34;9642:3;9627:19;;9609:232::o;9846:398::-;10073:25;;;10146:4;10134:17;;;;10129:2;10114:18;;10107:45;10183:2;10168:18;;10161:34;10226:2;10211:18;;10204:34;10060:3;10045:19;;10027:217::o;10249:219::-;;10396:2;10385:9;10378:21;10416:46;10458:2;10447:9;10443:18;10435:6;10416:46;:::i;10699:347::-;10901:2;10883:21;;;10940:2;10920:18;;;10913:30;10979:25;10974:2;10959:18;;10952:53;11037:2;11022:18;;10873:173::o;11051:356::-;11253:2;11235:21;;;11272:18;;;11265:30;11331:34;11326:2;11311:18;;11304:62;11398:2;11383:18;;11225:182::o;11412:414::-;11614:2;11596:21;;;11653:2;11633:18;;;11626:30;11692:34;11687:2;11672:18;;11665:62;-1:-1:-1;;;11758:2:20;11743:18;;11736:48;11816:3;11801:19;;11586:240::o;11831:402::-;12033:2;12015:21;;;12072:2;12052:18;;;12045:30;12111:34;12106:2;12091:18;;12084:62;-1:-1:-1;;;12177:2:20;12162:18;;12155:36;12223:3;12208:19;;12005:228::o;12238:352::-;12440:2;12422:21;;;12479:2;12459:18;;;12452:30;12518;12513:2;12498:18;;12491:58;12581:2;12566:18;;12412:178::o;12595:401::-;12797:2;12779:21;;;12836:2;12816:18;;;12809:30;12875:34;12870:2;12855:18;;12848:62;-1:-1:-1;;;12941:2:20;12926:18;;12919:35;12986:3;12971:19;;12769:227::o;13001:352::-;13203:2;13185:21;;;13242:2;13222:18;;;13215:30;13281;13276:2;13261:18;;13254:58;13344:2;13329:18;;13175:178::o;13358:350::-;13560:2;13542:21;;;13599:2;13579:18;;;13572:30;13638:28;13633:2;13618:18;;13611:56;13699:2;13684:18;;13532:176::o;13713:400::-;13915:2;13897:21;;;13954:2;13934:18;;;13927:30;13993:34;13988:2;13973:18;;13966:62;-1:-1:-1;;;14059:2:20;14044:18;;14037:34;14103:3;14088:19;;13887:226::o;14118:349::-;14320:2;14302:21;;;14359:2;14339:18;;;14332:30;14398:27;14393:2;14378:18;;14371:55;14458:2;14443:18;;14292:175::o;14472:408::-;14674:2;14656:21;;;14713:2;14693:18;;;14686:30;14752:34;14747:2;14732:18;;14725:62;-1:-1:-1;;;14818:2:20;14803:18;;14796:42;14870:3;14855:19;;14646:234::o;14885:399::-;15087:2;15069:21;;;15126:2;15106:18;;;15099:30;15165:34;15160:2;15145:18;;15138:62;-1:-1:-1;;;15231:2:20;15216:18;;15209:33;15274:3;15259:19;;15059:225::o;15289:401::-;15491:2;15473:21;;;15530:2;15510:18;;;15503:30;15569:34;15564:2;15549:18;;15542:62;-1:-1:-1;;;15635:2:20;15620:18;;15613:35;15680:3;15665:19;;15463:227::o;15695:405::-;15897:2;15879:21;;;15936:2;15916:18;;;15909:30;15975:34;15970:2;15955:18;;15948:62;-1:-1:-1;;;16041:2:20;16026:18;;16019:39;16090:3;16075:19;;15869:231::o;16105:420::-;16307:2;16289:21;;;16346:2;16326:18;;;16319:30;16385:34;16380:2;16365:18;;16358:62;16456:26;16451:2;16436:18;;16429:54;16515:3;16500:19;;16279:246::o;16530:405::-;16732:2;16714:21;;;16771:2;16751:18;;;16744:30;16810:34;16805:2;16790:18;;16783:62;-1:-1:-1;;;16876:2:20;16861:18;;16854:39;16925:3;16910:19;;16704:231::o;16940:399::-;17142:2;17124:21;;;17181:2;17161:18;;;17154:30;17220:34;17215:2;17200:18;;17193:62;-1:-1:-1;;;17286:2:20;17271:18;;17264:33;17329:3;17314:19;;17114:225::o;17344:356::-;17546:2;17528:21;;;17565:18;;;17558:30;17624:34;17619:2;17604:18;;17597:62;17691:2;17676:18;;17518:182::o;17705:356::-;17907:2;17889:21;;;17926:18;;;17919:30;17985:34;17980:2;17965:18;;17958:62;18052:2;18037:18;;17879:182::o;18066:356::-;18268:2;18250:21;;;18287:18;;;18280:30;18346:34;18341:2;18326:18;;18319:62;18413:2;18398:18;;18240:182::o;18427:408::-;18629:2;18611:21;;;18668:2;18648:18;;;18641:30;18707:34;18702:2;18687:18;;18680:62;-1:-1:-1;;;18773:2:20;18758:18;;18751:42;18825:3;18810:19;;18601:234::o;18840:356::-;19042:2;19024:21;;;19061:18;;;19054:30;19120:34;19115:2;19100:18;;19093:62;19187:2;19172:18;;19014:182::o;19201:397::-;19403:2;19385:21;;;19442:2;19422:18;;;19415:30;19481:34;19476:2;19461:18;;19454:62;-1:-1:-1;;;19547:2:20;19532:18;;19525:31;19588:3;19573:19;;19375:223::o;19603:398::-;19805:2;19787:21;;;19844:2;19824:18;;;19817:30;19883:34;19878:2;19863:18;;19856:62;-1:-1:-1;;;19949:2:20;19934:18;;19927:32;19991:3;19976:19;;19777:224::o;20006:402::-;20208:2;20190:21;;;20247:2;20227:18;;;20220:30;20286:34;20281:2;20266:18;;20259:62;-1:-1:-1;;;20352:2:20;20337:18;;20330:36;20398:3;20383:19;;20180:228::o;20413:350::-;20615:2;20597:21;;;20654:2;20634:18;;;20627:30;20693:28;20688:2;20673:18;;20666:56;20754:2;20739:18;;20587:176::o;20768:397::-;20970:2;20952:21;;;21009:2;20989:18;;;20982:30;21048:34;21043:2;21028:18;;21021:62;-1:-1:-1;;;21114:2:20;21099:18;;21092:31;21155:3;21140:19;;20942:223::o;21170:342::-;21372:2;21354:21;;;21411:2;21391:18;;;21384:30;-1:-1:-1;;;21445:2:20;21430:18;;21423:48;21503:2;21488:18;;21344:168::o;21517:346::-;21719:2;21701:21;;;21758:2;21738:18;;;21731:30;-1:-1:-1;;;21792:2:20;21777:18;;21770:52;21854:2;21839:18;;21691:172::o;21868:413::-;22070:2;22052:21;;;22109:2;22089:18;;;22082:30;22148:34;22143:2;22128:18;;22121:62;-1:-1:-1;;;22214:2:20;22199:18;;22192:47;22271:3;22256:19;;22042:239::o;22286:351::-;22488:2;22470:21;;;22527:2;22507:18;;;22500:30;22566:29;22561:2;22546:18;;22539:57;22628:2;22613:18;;22460:177::o;22642:352::-;22844:2;22826:21;;;22883:2;22863:18;;;22856:30;22922;22917:2;22902:18;;22895:58;22985:2;22970:18;;22816:178::o;22999:397::-;23201:2;23183:21;;;23240:2;23220:18;;;23213:30;23279:34;23274:2;23259:18;;23252:62;-1:-1:-1;;;23345:2:20;23330:18;;23323:31;23386:3;23371:19;;23173:223::o;23583:128::-;;23654:1;23650:6;23647:1;23644:13;23641:2;;;23660:18;;:::i;:::-;-1:-1:-1;23696:9:20;;23631:80::o;23716:120::-;;23782:1;23772:2;;23787:18;;:::i;:::-;-1:-1:-1;23821:9:20;;23762:74::o;23841:168::-;;23947:1;23943;23939:6;23935:14;23932:1;23929:21;23924:1;23917:9;23910:17;23906:45;23903:2;;;23954:18;;:::i;:::-;-1:-1:-1;23994:9:20;;23893:116::o;24014:125::-;;24082:1;24079;24076:8;24073:2;;;24087:18;;:::i;:::-;-1:-1:-1;24124:9:20;;24063:76::o;24144:258::-;24216:1;24226:113;24240:6;24237:1;24234:13;24226:113;;;24316:11;;;24310:18;24297:11;;;24290:39;24262:2;24255:10;24226:113;;;24357:6;24354:1;24351:13;24348:2;;;-1:-1:-1;;24392:1:20;24374:16;;24367:27;24197:205::o;24407:380::-;24492:1;24482:12;;24539:1;24529:12;;;24550:2;;24604:4;24596:6;24592:17;24582:27;;24550:2;24657;24649:6;24646:14;24626:18;24623:38;24620:2;;;24703:10;24698:3;24694:20;24691:1;24684:31;24738:4;24735:1;24728:15;24766:4;24763:1;24756:15;24620:2;;24462:325;;;:::o;24792:135::-;;-1:-1:-1;;24852:17:20;;24849:2;;;24872:18;;:::i;:::-;-1:-1:-1;24919:1:20;24908:13;;24839:88::o;24932:112::-;;24990:1;24980:2;;24995:18;;:::i;:::-;-1:-1:-1;25029:9:20;;24970:74::o;25049:127::-;25110:10;25105:3;25101:20;25098:1;25091:31;25141:4;25138:1;25131:15;25165:4;25162:1;25155:15;25181:127;25242:10;25237:3;25233:20;25230:1;25223:31;25273:4;25270:1;25263:15;25297:4;25294:1;25287:15;25313:127;25374:10;25369:3;25365:20;25362:1;25355:31;25405:4;25402:1;25395:15;25429:4;25426:1;25419:15;25445:133;-1:-1:-1;;;;;25522:31:20;;25512:42;;25502:2;;25568:1;25565;25558:12;25583:133;-1:-1:-1;;;;;;25659:32:20;;25649:43;;25639:2;;25706:1;25703;25696:12

ipfs://dca3278421222ada84b75ee6113591b2cfc700daa50cee8cb3a5672bb28a2c8f