Contract 0x4a891f2cba00cf8442a1d5a9219463453d326ba8 1

/**
 *Submitted for verification at moonriver.moonscan.io on 2022-02-16
*/

// File: interfaces/Address.sol

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
// File: interfaces/IERC20.sol

pragma solidity >=0.5.0;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}
// File: interfaces/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

pragma solidity ^0.8.4;

interface ITokenDeployer {
    event CreateToken(address tokenAddress, string name, string symbol, uint256 supply);

    function factory() external returns (address);
    function tokenType() external returns (string memory);
    function deploy(bytes calldata arguments) external returns (address token);
}
// File: interfaces/ITokenFactory.sol

pragma solidity =0.8.4;

interface ITokenFactory {
    
    event feeReceiverChanged(address indexed previousFeeReceiver, address indexed newFeeReceiver);

    function feeToken() external view returns (address address_);
    function creationFee() external view returns (uint256 creationFee_);
    function feeReceiver() external view returns (address address_);
    function padSwapRouter() external view returns (address address_);

    function getTokenCreator(address _token) external view returns  (address creator_);
    function getTokensBy(address _owner, uint256 _index) external view returns  (address token_);
    function tokenModels(address _tokenBuilder) external view returns  (bool enabled_);
    function allTokens(uint256 _index) external view returns (address token_);
    function getTokensLength(address _owner) external view returns (uint256 length_);
    function getAllTokensLength() external view returns (uint256 length_);

    function changeCreationFee(uint256 _value) external;
    function changeFeeToken(address _address) external;
    function changeRouter(address _address) external;
    function addTokenModel(address _address) external;
    function removeTokenModel(address _address) external;
    

    function createToken(address _tokenModel, bytes calldata _arguments) external returns (address address_);
}

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


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: TokenFactory.sol

pragma solidity =0.8.4;






contract TokenFactory is ITokenFactory, Ownable {

    using SafeERC20 for IERC20;
    
    address public override feeToken;
    uint256 public override creationFee;
    address public override feeReceiver;
    address public override padSwapRouter;

    mapping(address => address) public override getTokenCreator; //token [address] => token creator [address]
    mapping(address => address[]) public override getTokensBy; //token creator [address] => all tokens by token creator [ address[] ]
    mapping(address => bool) public override tokenModels; //token builder contract [address] => enabled [bool]
    
    address[] public override allTokens;

    constructor(address _feeToken, address _feeReceiver, uint256 _creationFee, address _padSwapRouter) {
        feeToken = _feeToken;
        feeReceiver = _feeReceiver;
        creationFee = _creationFee;
        padSwapRouter = _padSwapRouter;
    }

    function getTokensLength(address _owner) external view override returns (uint256 length_) {
        length_ = getTokensBy[_owner].length;
        return length_;
    }
    
    function getAllTokensLength() external view override returns (uint256 length_) {
        length_ = allTokens.length;
        return length_;
    }

    function changeCreationFee(uint256 _creationFee) external override onlyOwner {
        creationFee = _creationFee;
    }

    function changeFeeToken(address _feeToken) external override onlyOwner {
        feeToken = _feeToken;
    }
    
    function changeRouter(address _router) external override onlyOwner {
        padSwapRouter = _router;
    }

    function addTokenModel(address _address) external override onlyOwner {
        tokenModels[_address] = true;
    }

    function removeTokenModel(address _address) external override onlyOwner {
        tokenModels[_address] = false;
    }

    function createToken(address _tokenModel, bytes calldata _arguments) external override returns (address address_) {
        require(tokenModels[_tokenModel] == true, "ERROR: Token model not found");
        IERC20(feeToken).safeTransferFrom(msg.sender, address(this), creationFee);
        address_ = address(ITokenDeployer(_tokenModel).deploy(_arguments));
        return address_;
    }
}

[{"inputs":[{"internalType":"address","name":"_feeToken","type":"address"},{"internalType":"address","name":"_feeReceiver","type":"address"},{"internalType":"uint256","name":"_creationFee","type":"uint256"},{"internalType":"address","name":"_padSwapRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"previousFeeReceiver","type":"address"},{"indexed":true,"internalType":"address","name":"newFeeReceiver","type":"address"}],"name":"feeReceiverChanged","type":"event"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addTokenModel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_creationFee","type":"uint256"}],"name":"changeCreationFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeToken","type":"address"}],"name":"changeFeeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"changeRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenModel","type":"address"},{"internalType":"bytes","name":"_arguments","type":"bytes"}],"name":"createToken","outputs":[{"internalType":"address","name":"address_","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"creationFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllTokensLength","outputs":[{"internalType":"uint256","name":"length_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"getTokenCreator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"getTokensBy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getTokensLength","outputs":[{"internalType":"uint256","name":"length_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"padSwapRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeTokenModel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenModels","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000165dbb08de0476271714952c3c1f068693bd60d70000000000000000000000007b7b667905d6503cb9b47d1ceb8f71ae3a1db3b90000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000790d4b443edb9ce9a8d1aec585edd89e51132d2c

-----Decoded View---------------
Arg [0] : _feeToken (address): 0x165dbb08de0476271714952c3c1f068693bd60d7
Arg [1] : _feeReceiver (address): 0x7b7b667905d6503cb9b47d1ceb8f71ae3a1db3b9
Arg [2] : _creationFee (uint256): 1000000000000000000
Arg [3] : _padSwapRouter (address): 0x790d4b443edb9ce9a8d1aec585edd89e51132d2c

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000165dbb08de0476271714952c3c1f068693bd60d7
Arg [1] : 0000000000000000000000007b7b667905d6503cb9b47d1ceb8f71ae3a1db3b9
Arg [2] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [3] : 000000000000000000000000790d4b443edb9ce9a8d1aec585edd89e51132d2c

18592:2290:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18811:37;;;;;-1:-1:-1;;;;;18811:37:0;;;;;;-1:-1:-1;;;;;2593:32:1;;;2575:51;;2563:2;2548:18;18811:37:0;;;;;;;;19526:170;;;;;;:::i;:::-;-1:-1:-1;;;;;19637:19:0;19599:15;19637:19;;;:11;:19;;;;;:26;;19526:170;;;;6440:25:1;;;6428:2;6413:18;19526:170:0;6395:76:1;19103:52:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3182:14:1;;3175:22;3157:41;;3145:2;3130:18;19103:52:0;3112:92:1;19995:110:0;;;;;;:::i;:::-;;:::i;:::-;;20117:109;;;;;;:::i;:::-;;:::i;20358:120::-;;;;;;:::i;:::-;;:::i;18968:57::-;;;;;;:::i;:::-;;:::i;19708:149::-;19808:9;:16;19708:149;;19221:35;;;;;;:::i;:::-;;:::i;18688:32::-;;;;;-1:-1:-1;;;;;18688:32:0;;;20486:393;;;;;;:::i;:::-;;:::i;17709:103::-;;;:::i;17058:87::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;17058:87;;19865:122;;;;;;:::i;:::-;;:::i;18769:35::-;;;;;-1:-1:-1;;;;;18769:35:0;;;18857:59;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;18857:59:0;;;18727:35;;;;;;17967:201;;;;;;:::i;:::-;;:::i;20234:116::-;;;;;;:::i;:::-;;:::i;19995:110::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;;;;;;;;;20077:8:::1;:20:::0;;-1:-1:-1;;;;;;20077:20:0::1;-1:-1:-1::0;;;;;20077:20:0;;;::::1;::::0;;;::::1;::::0;;19995:110::o;20117:109::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;20195:13:::1;:23:::0;;-1:-1:-1;;;;;;20195:23:0::1;-1:-1:-1::0;;;;;20195:23:0;;;::::1;::::0;;;::::1;::::0;;20117:109::o;20358:120::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20441:21:0::1;20465:5;20441:21:::0;;;:11:::1;:21;::::0;;;;:29;;-1:-1:-1;;20441:29:0::1;::::0;;20358:120::o;18968:57::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18968:57:0;;-1:-1:-1;18968:57:0;;-1:-1:-1;18968:57:0:o;19221:35::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19221:35:0;;-1:-1:-1;19221:35:0;:::o;20486:393::-;-1:-1:-1;;;;;20619:24:0;;20582:16;20619:24;;;:11;:24;;;;;;;;:32;;:24;:32;20611:73;;;;-1:-1:-1;;;20611:73:0;;5009:2:1;20611:73:0;;;4991:21:1;5048:2;5028:18;;;5021:30;5087;5067:18;;;5060:58;5135:18;;20611:73:0;4981:178:1;20611:73:0;20756:11;;20702:8;;20695:73;;-1:-1:-1;;;;;20702:8:0;;;;20729:10;;20749:4;;20695:33;:73::i;:::-;20798:46;;-1:-1:-1;;;20798:46:0;;-1:-1:-1;;;;;20798:34:0;;;;;:46;;20833:10;;;;20798:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20779:66;;20486:393;;;;;;:::o;17709:103::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;17774:30:::1;17801:1;17774:18;:30::i;:::-;17709:103::o:0;19865:122::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;19953:11:::1;:26:::0;19865:122::o;17967:201::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18056:22:0;::::1;18048:73;;;::::0;-1:-1:-1;;;18048:73:0;;4195:2:1;18048:73:0::1;::::0;::::1;4177:21:1::0;4234:2;4214:18;;;4207:30;4273:34;4253:18;;;4246:62;-1:-1:-1;;;4324:18:1;;;4317:36;4370:19;;18048:73:0::1;4167:228:1::0;18048:73:0::1;18132:28;18151:8;18132:18;:28::i;:::-;17967:201:::0;:::o;20234:116::-;17104:7;17131:6;-1:-1:-1;;;;;17131:6:0;15862:10;17278:23;17270:68;;;;-1:-1:-1;;;17270:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20314:21:0::1;;::::0;;;:11:::1;:21;::::0;;;;:28;;-1:-1:-1;;20314:28:0::1;20338:4;20314:28;::::0;;20234:116::o;10224:248::-;10395:68;;;-1:-1:-1;;;;;2895:15:1;;;10395:68:0;;;2877:34:1;2947:15;;2927:18;;;2920:43;2979:18;;;;2972:34;;;10395:68:0;;;;;;;;;;2812:18:1;;;;10395:68:0;;;;;;;;-1:-1:-1;;;;;10395:68:0;-1:-1:-1;;;10395:68:0;;;10368:96;;10388:5;;10368:19;:96::i;:::-;10224:248;;;;:::o;18328:191::-;18402:16;18421:6;;-1:-1:-1;;;;;18438:17:0;;;-1:-1:-1;;;;;;18438:17:0;;;;;;18471:40;;18421:6;;;;;;;18471:40;;18402:16;18471:40;18328:191;;:::o;12578:716::-;13002:23;13028:69;13056:4;13028:69;;;;;;;;;;;;;;;;;13036:5;-1:-1:-1;;;;;13028:27:0;;;:69;;;;;:::i;:::-;13112:17;;13002:95;;-1:-1:-1;13112:21:0;13108:179;;13209:10;13198:30;;;;;;;;;;;;:::i;:::-;13190:85;;;;-1:-1:-1;;;13190:85:0;;6085:2:1;13190:85:0;;;6067:21:1;6124:2;6104:18;;;6097:30;6163:34;6143:18;;;6136:62;-1:-1:-1;;;6214:18:1;;;6207:40;6264:19;;13190:85:0;6057:232:1;13190:85:0;12578:716;;;:::o;3942:229::-;4079:12;4111:52;4133:6;4141:4;4147:1;4150:12;4079;-1:-1:-1;;;;;1492:19:0;;;5349:60;;;;-1:-1:-1;;;5349:60:0;;5727:2:1;5349:60:0;;;5709:21:1;5766:2;5746:18;;;5739:30;5805:31;5785:18;;;5778:59;5854:18;;5349:60:0;5699:179:1;5349:60:0;5423:12;5437:23;5464:6;-1:-1:-1;;;;;5464:11:0;5483:5;5490:4;5464:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5422:73;;;;5513:51;5530:7;5539:10;5551:12;5513:16;:51::i;:::-;5506:58;5062:510;-1:-1:-1;;;;;;;5062:510:0:o;7748:712::-;7898:12;7927:7;7923:530;;;-1:-1:-1;7958:10:0;7951:17;;7923:530;8072:17;;:21;8068:374;;8270:10;8264:17;8331:15;8318:10;8314:2;8310:19;8303:44;8218:148;8413:12;8406:20;;-1:-1:-1;;;8406:20:0;;;;;;;;:::i;14:257:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:31;235:5;210:31;:::i;276:261::-;346:6;399:2;387:9;378:7;374:23;370:32;367:2;;;420:6;412;405:22;367:2;457:9;451:16;476:31;501:5;476:31;:::i;542:776::-;621:6;629;637;690:2;678:9;669:7;665:23;661:32;658:2;;;711:6;703;696:22;658:2;755:9;742:23;774:31;799:5;774:31;:::i;:::-;824:5;-1:-1:-1;880:2:1;865:18;;852:32;903:18;933:14;;;930:2;;;965:6;957;950:22;930:2;1008:6;997:9;993:22;983:32;;1053:7;1046:4;1042:2;1038:13;1034:27;1024:2;;1080:6;1072;1065:22;1024:2;1125;1112:16;1151:2;1143:6;1140:14;1137:2;;;1172:6;1164;1157:22;1137:2;1222:7;1217:2;1208:6;1204:2;1200:15;1196:24;1193:37;1190:2;;;1248:6;1240;1233:22;1190:2;1284;1280;1276:11;1266:21;;1306:6;1296:16;;;;;648:670;;;;;:::o;1323:325::-;1391:6;1399;1452:2;1440:9;1431:7;1427:23;1423:32;1420:2;;;1473:6;1465;1458:22;1420:2;1517:9;1504:23;1536:31;1561:5;1536:31;:::i;:::-;1586:5;1638:2;1623:18;;;;1610:32;;-1:-1:-1;;;1410:238:1:o;1653:297::-;1720:6;1773:2;1761:9;1752:7;1748:23;1744:32;1741:2;;;1794:6;1786;1779:22;1741:2;1831:9;1825:16;1884:5;1877:13;1870:21;1863:5;1860:32;1850:2;;1911:6;1903;1896:22;1955:190;2014:6;2067:2;2055:9;2046:7;2042:23;2038:32;2035:2;;;2088:6;2080;2073:22;2035:2;-1:-1:-1;2116:23:1;;2025:120;-1:-1:-1;2025:120:1:o;2150:274::-;2279:3;2317:6;2311:13;2333:53;2379:6;2374:3;2367:4;2359:6;2355:17;2333:53;:::i;:::-;2402:16;;;;;2287:137;-1:-1:-1;;2287:137:1:o;3209:391::-;3366:2;3355:9;3348:21;3405:6;3400:2;3389:9;3385:18;3378:34;3462:6;3454;3449:2;3438:9;3434:18;3421:48;3329:4;3489:22;;;3513:2;3485:31;;;3478:45;;;;3584:2;3563:15;;;-1:-1:-1;;3559:29:1;3544:45;3540:54;;3338:262;-1:-1:-1;3338:262:1:o;3605:383::-;3754:2;3743:9;3736:21;3717:4;3786:6;3780:13;3829:6;3824:2;3813:9;3809:18;3802:34;3845:66;3904:6;3899:2;3888:9;3884:18;3879:2;3871:6;3867:15;3845:66;:::i;:::-;3972:2;3951:15;-1:-1:-1;;3947:29:1;3932:45;;;;3979:2;3928:54;;3726:262;-1:-1:-1;;3726:262:1:o;5164:356::-;5366:2;5348:21;;;5385:18;;;5378:30;5444:34;5439:2;5424:18;;5417:62;5511:2;5496:18;;5338:182::o;6476:258::-;6548:1;6558:113;6572:6;6569:1;6566:13;6558:113;;;6648:11;;;6642:18;6629:11;;;6622:39;6594:2;6587:10;6558:113;;;6689:6;6686:1;6683:13;6680:2;;;-1:-1:-1;;6724:1:1;6706:16;;6699:27;6529:205::o;6739:131::-;-1:-1:-1;;;;;6814:31:1;;6804:42;;6794:2;;6860:1;6857;6850:12

ipfs://eec38d6328cbfcede2ae6fce4a487200356b8def309f8878bcafb9dc3c702370