Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

/*

 /$$$$$$$$ /$$$$$$ /$$   /$$  /$$$$$$  /$$$$$$$$ /$$   /$$ /$$     /$$
| $$_____/|_  $$_/| $$$ | $$ /$$__  $$| $$_____/| $$  / $$|  $$   /$$/
| $$        | $$  | $$$$| $$| $$  \__/| $$      |  $$/ $$/ \  $$ /$$/
| $$$$$     | $$  | $$ $$ $$|  $$$$$$ | $$$$$    \  $$$$/   \  $$$$/
| $$__/     | $$  | $$  $$$$ \____  $$| $$__/     >$$  $$    \  $$/
| $$        | $$  | $$\  $$$ /$$  \ $$| $$       /$$/\  $$    | $$
| $$       /$$$$$$| $$ \  $$|  $$$$$$/| $$$$$$$$| $$  \ $$    | $$
|__/      |______/|__/  \__/ \______/ |________/|__/  |__/    |__/


https://finsexy.com

by steviep.eth

*/

pragma solidity ^0.8.23;

import "./SexyProxy.sol";


interface FastCash {
  function transfer(address to, uint256 amount) external;
}

contract VinceSlickson is FinDomBaseLight {
  FastCash public fastcash;
  uint256 public fastcashPrice = 0.01 ether;
  event FastCashSaleMade(address indexed to, uint256 amount);

  constructor(address fastcashAddr, address owner_, address router) FinDomBaseLight(owner_, router) {
    fastcash = FastCash(fastcashAddr);
  }

  function buyFastCash() external payable {
    require(msg.value >= fastcashPrice, "Don't waste Vince's time");
    require(_tributes[msg.sender] >= 0.01 ether, "Must wet Vince's whistle");

    uint256 amount = (msg.value  * 1 ether) / fastcashPrice;
    emit FastCashSaleMade(msg.sender, amount);
    fastcash.transfer(msg.sender, amount);
  }

  function updateFastCashPrice(uint256 price) external onlyOwner {
    fastcashPrice = price;
  }

  function compFastCash(address to, uint256 amount) external onlyOwner {
    fastcash.transfer(to, amount);
  }
}

// SPDX-License-Identifier: MIT

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


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

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

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

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

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

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

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

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

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

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

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

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


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


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

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

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


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

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

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

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

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

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

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

    /*
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

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

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

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

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

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

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

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

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

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


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

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


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

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

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

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

    /*
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */

    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


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


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

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

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

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

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

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

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

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


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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).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 {}
}


/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _burn(tokenId);
    }
}


// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overridden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}


/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
    bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}

// SPDX-License-Identifier: MIT

/*

 /$$$$$$$$ /$$$$$$ /$$   /$$  /$$$$$$  /$$$$$$$$ /$$   /$$ /$$     /$$
| $$_____/|_  $$_/| $$$ | $$ /$$__  $$| $$_____/| $$  / $$|  $$   /$$/
| $$        | $$  | $$$$| $$| $$  \__/| $$      |  $$/ $$/ \  $$ /$$/
| $$$$$     | $$  | $$ $$ $$|  $$$$$$ | $$$$$    \  $$$$/   \  $$$$/
| $$__/     | $$  | $$  $$$$ \____  $$| $$__/     >$$  $$    \  $$/
| $$        | $$  | $$\  $$$ /$$  \ $$| $$       /$$/\  $$    | $$
| $$       /$$$$$$| $$ \  $$|  $$$$$$/| $$$$$$$$| $$  \ $$    | $$
|__/      |______/|__/  \__/ \______/ |________/|__/  |__/    |__/


https://finsexy.com

by steviep.eth

*/

pragma solidity ^0.8.23;

import "./ProxyDependencies.sol";


interface IERC20 {
  function transfer(address to, uint256 value) external returns (bool);
}

interface IERC1155 {
  function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}

abstract contract TokenWithdrawer is Ownable {
  function withdraw() external onlyOwner {
    payable(owner()).transfer(address(this).balance);
  }

  function withdrawERC20(address erc20, uint256 amount) external onlyOwner {
    IERC20(erc20).transfer(msg.sender, amount);
  }

  function withdrawERC721(address erc721, uint256 tokenId) external onlyOwner {
    IERC721(erc721).safeTransferFrom(address(this), msg.sender, tokenId);
  }

  function withdrawERC1155(address erc1155, uint256 tokenId, uint256 amount, bytes calldata data) external onlyOwner {
    IERC1155(erc1155).safeTransferFrom(address(this), msg.sender, tokenId, amount, data);
  }

  function onERC721Received(address, address, uint256, bytes calldata) external pure returns(bytes4) {
    return this.onERC721Received.selector;
  }

  function onERC1155Received(address, address, uint256, uint256, bytes calldata) external pure returns (bytes4) {
    return this.onERC1155Received.selector;
  }

  function onERC1155BatchReceived(address, address, uint256[] calldata, uint256[] calldata, bytes calldata) external pure returns (bytes4) {
    return this.onERC1155BatchReceived.selector;
  }
}


interface ISexyRouter {
  function vip() external view returns (address);
  function baseURI() external view returns (address);
  function premium(address user) external view returns (uint256);
}


abstract contract FinDomTribute is TokenWithdrawer {
  mapping(address => uint256) internal _tributes;
  event Send(address indexed from, uint256 amount);

  ISexyRouter public router;

  constructor(address owner_, address router_) {
    _setOwner(owner_);
    router = ISexyRouter(router_);
  }

  function tributes(address sender) external virtual view returns (uint256) {
    return _tributes[sender];
  }

  function creditTribute(address recipient, uint256 amount) external {
    require(router.vip() == msg.sender, 'Only VIP contract can credit tributes');
    _receive(recipient, amount);
  }

  receive() external payable {
    _receive(msg.sender, msg.value / router.premium(msg.sender));
  }

  function _receive(address sender, uint256 value) internal virtual {
    emit Send(sender, value);
    _tributes[sender] += value;
  }
}


interface InternalMintCheck {
  function mintCheck(address sender, uint256 amount) external returns (bool);
}

interface ITokenURI {
  function tokenURI(string memory name, string memory symbol, uint256 tokenId) external view returns (string memory);
  function isSpecial(string memory symbol, uint256 tokenId) external view returns (bool specialness);
}

contract FinDomBase is ERC721, FinDomTribute {
  uint256 public mintThreshold;
  string private _name;
  string private _symbol;

  bool private _isInitialized;

  address public externalMinter;
  bool public internalMintCheck;
  uint256 public totalSupply;
  uint256 public maxSupply;

  constructor (address owner_, address router_) ERC721('', '') FinDomTribute(owner_, router_) {}


  function initialize(
    string memory name_,
    string memory symbol_,
    uint256 mintThreshold_,
    address owner_,
    address router_,
    address externalMinter_,
    bool internalMintCheck_
  ) external {
    require(!_isInitialized, "Can't initialize more than once");
    _isInitialized = true;
    _name = name_;
    _symbol = symbol_;
    mintThreshold = mintThreshold_;
    router = ISexyRouter(router_);
    externalMinter = externalMinter_;
    internalMintCheck = internalMintCheck_;

    _setOwner(owner_);
  }

  function name() public view virtual override(ERC721) returns (string memory) {
   return  _name;
  }

  function symbol() public view virtual override(ERC721) returns (string memory) {
    return _symbol;
  }


  function exists(uint256 tokenId) external view returns (bool) {
    return _exists(tokenId);
  }

  function setMintThreshold(uint256 mintThreshold_) external onlyOwner {
    mintThreshold = mintThreshold_;
  }

  function mint(address to) external {
    require(externalMinter == msg.sender, 'Incorrect minting address');
    _mint(to, totalSupply);
    totalSupply++;
  }

  function isSpecial(uint256 tokenId) external view returns (bool) {
    return ITokenURI(router.baseURI()).isSpecial(_symbol, tokenId);
  }

  function _receive(address sender, uint256 value) internal override {
    emit Send(sender, value);
    _tributes[sender] += value;

    if (
      value >= mintThreshold
      || (
        _tributes[sender] % mintThreshold
        < (_tributes[sender] - value) % mintThreshold
      )
    ) {
      if (externalMinter != address(0)) return;
      if (internalMintCheck) {
        if (!InternalMintCheck(address(this)).mintCheck(sender, value)) return;
      }

      _mint(sender, totalSupply);
      totalSupply++;
    }

  }

  function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    return ITokenURI(router.baseURI()).tokenURI(_name, _symbol, tokenId);
  }
}

contract TokenURI {
  function tokenURI(uint256 tokenId) external view returns (string memory) {}
}

abstract contract ProxyBase is Proxy {
  bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

  struct AddressSlot {
    address value;
  }

  function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
    assembly {
      r.slot := slot
    }
  }

  function _implementation() internal override view returns (address) {
    return getAddressSlot(_IMPLEMENTATION_SLOT).value;
  }

  function implementation() public view returns (address) {
    return _implementation();
  }
}

contract FindomProxy is ProxyBase {
  constructor(
    string memory name,
    string memory symbol,
    uint256 mintThreshold,
    address implementationAddr,
    address owner_,
    address router
  ) {
    getAddressSlot(_IMPLEMENTATION_SLOT).value = implementationAddr;

    Address.functionDelegateCall(
        implementationAddr,
        abi.encodeWithSignature(
          "initialize(string,string,uint256,address,address,address,bool)",
          name, symbol, mintThreshold, owner_, router, address(0), false
        ),
        "Address: low-level delegate call failed"
    );
  }
}



contract FinDomBaseLight is FinDomTribute {
  constructor(address owner_, address router_) FinDomTribute(owner_, router_) {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"fastcashAddr","type":"address"},{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"router","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FastCashSaleMade","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":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Send","type":"event"},{"inputs":[],"name":"buyFastCash","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"compFastCash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"creditTribute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fastcash","outputs":[{"internalType":"contract FastCash","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fastcashPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract ISexyRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"tributes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"name":"updateFastCashPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc1155","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"withdrawERC1155","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc20","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc721","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"withdrawERC721","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000ca5228d1fe52d22db85e02ca305cddd9e573d75200000000000000000000000047144372eb383466d18fc91db9cd0396aa6c87a400000000000000000000000032e1bfd713d9fef8a5d1bc10592a2d0fc10b92ff

-----Decoded View---------------
Arg [0] : fastcashAddr (address): 0xcA5228D1fe52D22db85E02CA305cddD9E573D752
Arg [1] : owner_ (address): 0x47144372eb383466D18FC91DB9Cd0396Aa6c87A4
Arg [2] : router (address): 0x32e1bfD713D9feF8a5d1bC10592a2d0fC10B92fF

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000ca5228d1fe52d22db85e02ca305cddd9e573d752
Arg [1] : 00000000000000000000000047144372eb383466d18fc91db9cd0396aa6c87a4
Arg [2] : 00000000000000000000000032e1bfd713d9fef8a5d1bc10592a2d0fc10b92ff

766:886:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2922:60:1;2931:10;2955:6;;;;;;;;;;;:14;;;2970:10;2955:26;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2943:9;:38;;;;:::i;:::-;2922:8;:60::i;:::-;766:886:2;;;;;2698:187:1;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1577:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;972:98;;;;;;;;;;;;;:::i;:::-;;840:41:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;812:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19687:92:0;;;;;;;;;;;;;:::i;:::-;;1442:95:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19055:85:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2585:109:1;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1363:210;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1074:126;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1541:109:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1891:191:1;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1094:344:2;;;:::i;:::-;;1728:159:1;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19928:189:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1204:155:1;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2443:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2991:133;3073:6;3068:19;;;3081:5;3068:19;;;;;;:::i;:::-;;;;;;;;3114:5;3093:9;:17;3103:6;3093:17;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;2991:133;;:::o;2698:187::-;2795:10;2779:26;;:6;;;;;;;;;;;:10;;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:26;;;2771:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;2853:27;2862:9;2873:6;2853:8;:27::i;:::-;2698:187;;:::o;1577:147::-;1668:6;1689:30;;;1682:37;;1577:147;;;;;;;:::o;972:98::-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1025:7:1::1;:5;:7::i;:::-;1017:25;;:48;1043:21;1017:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;972:98::o:0;840:41:2:-;;;;:::o;812:24::-;;;;;;;;;;;;;:::o;19687:92:0:-;19278:12;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;19751:21:::1;19769:1;19751:9;:21::i;:::-;19687:92::o:0;1442:95:2:-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1527:5:2::1;1511:13;:21;;;;1442:95:::0;:::o;19055:85:0:-;19101:7;19127:6;;;;;;;;;;;19120:13;;19055:85;:::o;2585:109:1:-;2650:7;2672:9;:17;2682:6;2672:17;;;;;;;;;;;;;;;;2665:24;;2585:109;;;:::o;1363:210::-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1493:7:1::1;1484:34;;;1527:4;1534:10;1546:7;1555:6;1563:4;;1484:84;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;1363:210:::0;;;;;:::o;1074:126::-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1160:5:1::1;1153:22;;;1176:10;1188:6;1153:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1074:126:::0;;:::o;1541:109:2:-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1616:8:2::1;;;;;;;;;;;:17;;;1634:2;1638:6;1616:29;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;1541:109:::0;;:::o;1891:191:1:-;2020:6;2041:36;;;2034:43;;1891:191;;;;;;;;;;:::o;1094:344:2:-;1161:13;;1148:9;:26;;1140:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1242:10;1217:9;:21;1227:10;1217:21;;;;;;;;;;;;;;;;:35;;1209:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;1288:14;1330:13;;1319:7;1306:9;:20;;;;:::i;:::-;1305:38;;;;:::i;:::-;1288:55;;1371:10;1354:36;;;1383:6;1354:36;;;;;;:::i;:::-;;;;;;;;1396:8;;;;;;;;;;;:17;;;1414:10;1426:6;1396:37;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1134:304;1094:344::o;1728:159:1:-;1830:6;1851:31;;;1844:38;;1728:159;;;;;;;;:::o;19928:189:0:-;19278:12;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;20036:1:::1;20016:22;;:8;:22;;::::0;20008:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;20091:19;20101:8;20091:9;:19::i;:::-;19928:189:::0;:::o;1204:155:1:-;19278:12:0;:10;:12::i;:::-;19267:23;;:7;:5;:7::i;:::-;:23;;;19259:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1294:6:1::1;1286:32;;;1327:4;1334:10;1346:7;1286:68;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;1204:155:::0;;:::o;2443:25::-;;;;;;;;;;;;;:::o;15128:96:0:-;15181:7;15207:10;15200:17;;15128:96;:::o;20123:170::-;20179:16;20198:6;;;;;;;;;;;20179:25;;20223:8;20214:6;;:17;;;;;;;;;;;;;;;;;;20277:8;20246:40;;20267:8;20246:40;;;;;;;;;;;;20169:124;20123:170;:::o;7:126:3:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;674:117::-;783:1;780;773:12;797:117;906:1;903;896:12;920:77;957:7;986:5;975:16;;920:77;;;:::o;1003:122::-;1076:24;1094:5;1076:24;:::i;:::-;1069:5;1066:35;1056:63;;1115:1;1112;1105:12;1056:63;1003:122;:::o;1131:143::-;1188:5;1219:6;1213:13;1204:22;;1235:33;1262:5;1235:33;:::i;:::-;1131:143;;;;:::o;1280:351::-;1350:6;1399:2;1387:9;1378:7;1374:23;1370:32;1367:119;;;1405:79;;:::i;:::-;1367:119;1525:1;1550:64;1606:7;1597:6;1586:9;1582:22;1550:64;:::i;:::-;1540:74;;1496:128;1280:351;;;;:::o;1637:180::-;1685:77;1682:1;1675:88;1782:4;1779:1;1772:15;1806:4;1803:1;1796:15;1823:180;1871:77;1868:1;1861:88;1968:4;1965:1;1958:15;1992:4;1989:1;1982:15;2009:185;2049:1;2066:20;2084:1;2066:20;:::i;:::-;2061:25;;2100:20;2118:1;2100:20;:::i;:::-;2095:25;;2139:1;2129:35;;2144:18;;:::i;:::-;2129:35;2186:1;2183;2179:9;2174:14;;2009:185;;;;:::o;2200:122::-;2273:24;2291:5;2273:24;:::i;:::-;2266:5;2263:35;2253:63;;2312:1;2309;2302:12;2253:63;2200:122;:::o;2328:139::-;2374:5;2412:6;2399:20;2390:29;;2428:33;2455:5;2428:33;:::i;:::-;2328:139;;;;:::o;2473:::-;2519:5;2557:6;2544:20;2535:29;;2573:33;2600:5;2573:33;:::i;:::-;2473:139;;;;:::o;2618:474::-;2686:6;2694;2743:2;2731:9;2722:7;2718:23;2714:32;2711:119;;;2749:79;;:::i;:::-;2711:119;2869:1;2894:53;2939:7;2930:6;2919:9;2915:22;2894:53;:::i;:::-;2884:63;;2840:117;2996:2;3022:53;3067:7;3058:6;3047:9;3043:22;3022:53;:::i;:::-;3012:63;;2967:118;2618:474;;;;;:::o;3098:117::-;3207:1;3204;3197:12;3221:117;3330:1;3327;3320:12;3344:117;3453:1;3450;3443:12;3480:552;3537:8;3547:6;3597:3;3590:4;3582:6;3578:17;3574:27;3564:122;;3605:79;;:::i;:::-;3564:122;3718:6;3705:20;3695:30;;3748:18;3740:6;3737:30;3734:117;;;3770:79;;:::i;:::-;3734:117;3884:4;3876:6;3872:17;3860:29;;3938:3;3930:4;3922:6;3918:17;3908:8;3904:32;3901:41;3898:128;;;3945:79;;:::i;:::-;3898:128;3480:552;;;;;:::o;4038:963::-;4135:6;4143;4151;4159;4167;4216:3;4204:9;4195:7;4191:23;4187:33;4184:120;;;4223:79;;:::i;:::-;4184:120;4343:1;4368:53;4413:7;4404:6;4393:9;4389:22;4368:53;:::i;:::-;4358:63;;4314:117;4470:2;4496:53;4541:7;4532:6;4521:9;4517:22;4496:53;:::i;:::-;4486:63;;4441:118;4598:2;4624:53;4669:7;4660:6;4649:9;4645:22;4624:53;:::i;:::-;4614:63;;4569:118;4754:2;4743:9;4739:18;4726:32;4785:18;4777:6;4774:30;4771:117;;;4807:79;;:::i;:::-;4771:117;4920:64;4976:7;4967:6;4956:9;4952:22;4920:64;:::i;:::-;4902:82;;;;4697:297;4038:963;;;;;;;;:::o;5007:149::-;5043:7;5083:66;5076:5;5072:78;5061:89;;5007:149;;;:::o;5162:115::-;5247:23;5264:5;5247:23;:::i;:::-;5242:3;5235:36;5162:115;;:::o;5283:218::-;5374:4;5412:2;5401:9;5397:18;5389:26;;5425:69;5491:1;5480:9;5476:17;5467:6;5425:69;:::i;:::-;5283:218;;;;:::o;5507:118::-;5594:24;5612:5;5594:24;:::i;:::-;5589:3;5582:37;5507:118;;:::o;5631:222::-;5724:4;5762:2;5751:9;5747:18;5739:26;;5775:71;5843:1;5832:9;5828:17;5819:6;5775:71;:::i;:::-;5631:222;;;;:::o;5859:60::-;5887:3;5908:5;5901:12;;5859:60;;;:::o;5925:142::-;5975:9;6008:53;6026:34;6035:24;6053:5;6035:24;:::i;:::-;6026:34;:::i;:::-;6008:53;:::i;:::-;5995:66;;5925:142;;;:::o;6073:126::-;6123:9;6156:37;6187:5;6156:37;:::i;:::-;6143:50;;6073:126;;;:::o;6205:143::-;6272:9;6305:37;6336:5;6305:37;:::i;:::-;6292:50;;6205:143;;;:::o;6354:165::-;6458:54;6506:5;6458:54;:::i;:::-;6453:3;6446:67;6354:165;;:::o;6525:256::-;6635:4;6673:2;6662:9;6658:18;6650:26;;6686:88;6771:1;6760:9;6756:17;6747:6;6686:88;:::i;:::-;6525:256;;;;:::o;6787:329::-;6846:6;6895:2;6883:9;6874:7;6870:23;6866:32;6863:119;;;6901:79;;:::i;:::-;6863:119;7021:1;7046:53;7091:7;7082:6;7071:9;7067:22;7046:53;:::i;:::-;7036:63;;6992:117;6787:329;;;;:::o;7122:::-;7181:6;7230:2;7218:9;7209:7;7205:23;7201:32;7198:119;;;7236:79;;:::i;:::-;7198:119;7356:1;7381:53;7426:7;7417:6;7406:9;7402:22;7381:53;:::i;:::-;7371:63;;7327:117;7122:329;;;;:::o;7457:963::-;7554:6;7562;7570;7578;7586;7635:3;7623:9;7614:7;7610:23;7606:33;7603:120;;;7642:79;;:::i;:::-;7603:120;7762:1;7787:53;7832:7;7823:6;7812:9;7808:22;7787:53;:::i;:::-;7777:63;;7733:117;7889:2;7915:53;7960:7;7951:6;7940:9;7936:22;7915:53;:::i;:::-;7905:63;;7860:118;8017:2;8043:53;8088:7;8079:6;8068:9;8064:22;8043:53;:::i;:::-;8033:63;;7988:118;8173:2;8162:9;8158:18;8145:32;8204:18;8196:6;8193:30;8190:117;;;8226:79;;:::i;:::-;8190:117;8339:64;8395:7;8386:6;8375:9;8371:22;8339:64;:::i;:::-;8321:82;;;;8116:297;7457:963;;;;;;;;:::o;8443:568::-;8516:8;8526:6;8576:3;8569:4;8561:6;8557:17;8553:27;8543:122;;8584:79;;:::i;:::-;8543:122;8697:6;8684:20;8674:30;;8727:18;8719:6;8716:30;8713:117;;;8749:79;;:::i;:::-;8713:117;8863:4;8855:6;8851:17;8839:29;;8917:3;8909:4;8901:6;8897:17;8887:8;8883:32;8880:41;8877:128;;;8924:79;;:::i;:::-;8877:128;8443:568;;;;;:::o;9017:1569::-;9177:6;9185;9193;9201;9209;9217;9225;9233;9282:3;9270:9;9261:7;9257:23;9253:33;9250:120;;;9289:79;;:::i;:::-;9250:120;9409:1;9434:53;9479:7;9470:6;9459:9;9455:22;9434:53;:::i;:::-;9424:63;;9380:117;9536:2;9562:53;9607:7;9598:6;9587:9;9583:22;9562:53;:::i;:::-;9552:63;;9507:118;9692:2;9681:9;9677:18;9664:32;9723:18;9715:6;9712:30;9709:117;;;9745:79;;:::i;:::-;9709:117;9858:80;9930:7;9921:6;9910:9;9906:22;9858:80;:::i;:::-;9840:98;;;;9635:313;10015:2;10004:9;10000:18;9987:32;10046:18;10038:6;10035:30;10032:117;;;10068:79;;:::i;:::-;10032:117;10181:80;10253:7;10244:6;10233:9;10229:22;10181:80;:::i;:::-;10163:98;;;;9958:313;10338:3;10327:9;10323:19;10310:33;10370:18;10362:6;10359:30;10356:117;;;10392:79;;:::i;:::-;10356:117;10505:64;10561:7;10552:6;10541:9;10537:22;10505:64;:::i;:::-;10487:82;;;;10281:298;9017:1569;;;;;;;;;;;:::o;10592:1109::-;10698:6;10706;10714;10722;10730;10738;10787:3;10775:9;10766:7;10762:23;10758:33;10755:120;;;10794:79;;:::i;:::-;10755:120;10914:1;10939:53;10984:7;10975:6;10964:9;10960:22;10939:53;:::i;:::-;10929:63;;10885:117;11041:2;11067:53;11112:7;11103:6;11092:9;11088:22;11067:53;:::i;:::-;11057:63;;11012:118;11169:2;11195:53;11240:7;11231:6;11220:9;11216:22;11195:53;:::i;:::-;11185:63;;11140:118;11297:2;11323:53;11368:7;11359:6;11348:9;11344:22;11323:53;:::i;:::-;11313:63;;11268:118;11453:3;11442:9;11438:19;11425:33;11485:18;11477:6;11474:30;11471:117;;;11507:79;;:::i;:::-;11471:117;11620:64;11676:7;11667:6;11656:9;11652:22;11620:64;:::i;:::-;11602:82;;;;11396:298;10592:1109;;;;;;;;:::o;11707:146::-;11777:9;11810:37;11841:5;11810:37;:::i;:::-;11797:50;;11707:146;;;:::o;11859:171::-;11966:57;12017:5;11966:57;:::i;:::-;11961:3;11954:70;11859:171;;:::o;12036:262::-;12149:4;12187:2;12176:9;12172:18;12164:26;;12200:91;12288:1;12277:9;12273:17;12264:6;12200:91;:::i;:::-;12036:262;;;;:::o;12304:191::-;12344:3;12363:20;12381:1;12363:20;:::i;:::-;12358:25;;12397:20;12415:1;12397:20;:::i;:::-;12392:25;;12440:1;12437;12433:9;12426:16;;12461:3;12458:1;12455:10;12452:36;;;12468:18;;:::i;:::-;12452:36;12304:191;;;;:::o;12501:143::-;12558:5;12589:6;12583:13;12574:22;;12605:33;12632:5;12605:33;:::i;:::-;12501:143;;;;:::o;12650:351::-;12720:6;12769:2;12757:9;12748:7;12744:23;12740:32;12737:119;;;12775:79;;:::i;:::-;12737:119;12895:1;12920:64;12976:7;12967:6;12956:9;12952:22;12920:64;:::i;:::-;12910:74;;12866:128;12650:351;;;;:::o;13007:169::-;13091:11;13125:6;13120:3;13113:19;13165:4;13160:3;13156:14;13141:29;;13007:169;;;;:::o;13182:224::-;13322:34;13318:1;13310:6;13306:14;13299:58;13391:7;13386:2;13378:6;13374:15;13367:32;13182:224;:::o;13412:366::-;13554:3;13575:67;13639:2;13634:3;13575:67;:::i;:::-;13568:74;;13651:93;13740:3;13651:93;:::i;:::-;13769:2;13764:3;13760:12;13753:19;;13412:366;;;:::o;13784:419::-;13950:4;13988:2;13977:9;13973:18;13965:26;;14037:9;14031:4;14027:20;14023:1;14012:9;14008:17;14001:47;14065:131;14191:4;14065:131;:::i;:::-;14057:139;;13784:419;;;:::o;14209:182::-;14349:34;14345:1;14337:6;14333:14;14326:58;14209:182;:::o;14397:366::-;14539:3;14560:67;14624:2;14619:3;14560:67;:::i;:::-;14553:74;;14636:93;14725:3;14636:93;:::i;:::-;14754:2;14749:3;14745:12;14738:19;;14397:366;;;:::o;14769:419::-;14935:4;14973:2;14962:9;14958:18;14950:26;;15022:9;15016:4;15012:20;15008:1;14997:9;14993:17;14986:47;15050:131;15176:4;15050:131;:::i;:::-;15042:139;;14769:419;;;:::o;15194:168::-;15277:11;15311:6;15306:3;15299:19;15351:4;15346:3;15342:14;15327:29;;15194:168;;;;:::o;15368:146::-;15465:6;15460:3;15455;15442:30;15506:1;15497:6;15492:3;15488:16;15481:27;15368:146;;;:::o;15520:102::-;15561:6;15612:2;15608:7;15603:2;15596:5;15592:14;15588:28;15578:38;;15520:102;;;:::o;15650:314::-;15746:3;15767:70;15830:6;15825:3;15767:70;:::i;:::-;15760:77;;15847:56;15896:6;15891:3;15884:5;15847:56;:::i;:::-;15928:29;15950:6;15928:29;:::i;:::-;15923:3;15919:39;15912:46;;15650:314;;;;;:::o;15970:771::-;16203:4;16241:3;16230:9;16226:19;16218:27;;16255:71;16323:1;16312:9;16308:17;16299:6;16255:71;:::i;:::-;16336:72;16404:2;16393:9;16389:18;16380:6;16336:72;:::i;:::-;16418;16486:2;16475:9;16471:18;16462:6;16418:72;:::i;:::-;16500;16568:2;16557:9;16553:18;16544:6;16500:72;:::i;:::-;16620:9;16614:4;16610:20;16604:3;16593:9;16589:19;16582:49;16648:86;16729:4;16720:6;16712;16648:86;:::i;:::-;16640:94;;15970:771;;;;;;;;;:::o;16747:332::-;16868:4;16906:2;16895:9;16891:18;16883:26;;16919:71;16987:1;16976:9;16972:17;16963:6;16919:71;:::i;:::-;17000:72;17068:2;17057:9;17053:18;17044:6;17000:72;:::i;:::-;16747:332;;;;;:::o;17085:90::-;17119:7;17162:5;17155:13;17148:21;17137:32;;17085:90;;;:::o;17181:116::-;17251:21;17266:5;17251:21;:::i;:::-;17244:5;17241:32;17231:60;;17287:1;17284;17277:12;17231:60;17181:116;:::o;17303:137::-;17357:5;17388:6;17382:13;17373:22;;17404:30;17428:5;17404:30;:::i;:::-;17303:137;;;;:::o;17446:345::-;17513:6;17562:2;17550:9;17541:7;17537:23;17533:32;17530:119;;;17568:79;;:::i;:::-;17530:119;17688:1;17713:61;17766:7;17757:6;17746:9;17742:22;17713:61;:::i;:::-;17703:71;;17659:125;17446:345;;;;:::o;17797:174::-;17937:26;17933:1;17925:6;17921:14;17914:50;17797:174;:::o;17977:366::-;18119:3;18140:67;18204:2;18199:3;18140:67;:::i;:::-;18133:74;;18216:93;18305:3;18216:93;:::i;:::-;18334:2;18329:3;18325:12;18318:19;;17977:366;;;:::o;18349:419::-;18515:4;18553:2;18542:9;18538:18;18530:26;;18602:9;18596:4;18592:20;18588:1;18577:9;18573:17;18566:47;18630:131;18756:4;18630:131;:::i;:::-;18622:139;;18349:419;;;:::o;18774:174::-;18914:26;18910:1;18902:6;18898:14;18891:50;18774:174;:::o;18954:366::-;19096:3;19117:67;19181:2;19176:3;19117:67;:::i;:::-;19110:74;;19193:93;19282:3;19193:93;:::i;:::-;19311:2;19306:3;19302:12;19295:19;;18954:366;;;:::o;19326:419::-;19492:4;19530:2;19519:9;19515:18;19507:26;;19579:9;19573:4;19569:20;19565:1;19554:9;19550:17;19543:47;19607:131;19733:4;19607:131;:::i;:::-;19599:139;;19326:419;;;:::o;19751:410::-;19791:7;19814:20;19832:1;19814:20;:::i;:::-;19809:25;;19848:20;19866:1;19848:20;:::i;:::-;19843:25;;19903:1;19900;19896:9;19925:30;19943:11;19925:30;:::i;:::-;19914:41;;20104:1;20095:7;20091:15;20088:1;20085:22;20065:1;20058:9;20038:83;20015:139;;20134:18;;:::i;:::-;20015:139;19799:362;19751:410;;;;:::o;20167:225::-;20307:34;20303:1;20295:6;20291:14;20284:58;20376:8;20371:2;20363:6;20359:15;20352:33;20167:225;:::o;20398:366::-;20540:3;20561:67;20625:2;20620:3;20561:67;:::i;:::-;20554:74;;20637:93;20726:3;20637:93;:::i;:::-;20755:2;20750:3;20746:12;20739:19;;20398:366;;;:::o;20770:419::-;20936:4;20974:2;20963:9;20959:18;20951:26;;21023:9;21017:4;21013:20;21009:1;20998:9;20994:17;20987:47;21051:131;21177:4;21051:131;:::i;:::-;21043:139;;20770:419;;;:::o;21195:442::-;21344:4;21382:2;21371:9;21367:18;21359:26;;21395:71;21463:1;21452:9;21448:17;21439:6;21395:71;:::i;:::-;21476:72;21544:2;21533:9;21529:18;21520:6;21476:72;:::i;:::-;21558;21626:2;21615:9;21611:18;21602:6;21558:72;:::i;:::-;21195:442;;;;;;:::o

ipfs://0e294cdfe93bd0520f00e8e4bd6502e6dd96214762ee66aa7363afab3cc8a5c6