Contract 0xC8CDd2Ea6A5149ced1F2d225D16a775ee081C67D

/**
 *Submitted for verification at Arbiscan on 2021-11-19
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns token decimals.
     */
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

/**
 * @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);
            }
        }
    }
}
/**
 * @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");
        }
    }
}
interface IRouter {
    function trading() external view returns (address);

    function capPool() external view returns (address);

    function oracle() external view returns (address);

    function treasury() external view returns (address);

    function darkOracle() external view returns (address);

    function isSupportedCurrency(address currency) external view returns (bool);

    function currencies(uint256 index) external view returns (address);

    function currenciesLength() external view returns (uint256);

    function getDecimals(address currency) external view returns(uint8);

    function getPool(address currency) external view returns (address);

    function getPoolShare(address currency) external view returns(uint256);

    function getCapShare(address currency) external view returns(uint256);

    function getPoolRewards(address currency) external view returns (address);

    function getCapRewards(address currency) external view returns (address);
}
interface IRewards {
    function updateRewards(address account) external;

    function notifyRewardReceived(uint256 amount) external;
}
contract PoolCAP {

	using SafeERC20 for IERC20; 

	address public owner;
	address public router;

	address public cap; // CAP address

	mapping(address => uint256) private balances; // account => amount staked
	uint256 public totalSupply;

	// Events
    event DepositCAP(
    	address indexed user, 
    	uint256 amount
    );
    event WithdrawCAP(
    	address indexed user,
    	uint256 amount
    );

	constructor(address _cap) {
		owner = msg.sender;
		cap = _cap;
	}

	// Governance methods

	function setOwner(address newOwner) external onlyOwner {
		owner = newOwner;
	}

	function setRouter(address _router) external onlyOwner {
		router = _router;
	}

	function deposit(uint256 amount) external {

		require(amount > 0, "!amount");

		_updateRewards();

		totalSupply += amount;
		balances[msg.sender] += amount;

		IERC20(cap).safeTransferFrom(msg.sender, address(this), amount);

		emit DepositCAP(
			msg.sender,
			amount
		);

	}

	function withdraw(uint256 amount) external {
		
		require(amount > 0, "!amount");

		if (amount >= balances[msg.sender]) {
			amount = balances[msg.sender];
		}

		_updateRewards();

		totalSupply -= amount;
		balances[msg.sender] -= amount;

		IERC20(cap).safeTransfer(msg.sender, amount);

		emit WithdrawCAP(
			msg.sender,
			amount
		);

	}

	function getBalance(address account) external view returns(uint256) {
		return balances[account];
	}

	function _updateRewards() internal {
		uint256 length = IRouter(router).currenciesLength();
		for (uint256 i = 0; i < length; i++) {
			address currency = IRouter(router).currencies(i);
			address rewardsContract = IRouter(router).getCapRewards(currency);
			IRewards(rewardsContract).updateRewards(msg.sender);
		}
	}

	modifier onlyOwner() {
		require(msg.sender == owner, "!owner");
		_;
	}

}

[{"inputs":[{"internalType":"address","name":"_cap","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositCAP","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawCAP","type":"event"},{"inputs":[],"name":"cap","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"setRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000031d35296154279dc1984dcd93e392b1f946737b

-----Decoded View---------------
Arg [0] : _cap (address): 0x031d35296154279dc1984dcd93e392b1f946737b

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000031d35296154279dc1984dcd93e392b1f946737b

15913:1891:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16443:81;;;;;;:::i;:::-;;:::i;:::-;;16135:26;;;;;;;;;4703:25:1;;;4691:2;4676:18;16135:26:0;;;;;;;;16917:365;;;;;;:::i;:::-;;:::i;16020:18::-;;;;;-1:-1:-1;;;;;16020:18:0;;;;;;-1:-1:-1;;;;;1621:32:1;;;1603:51;;1591:2;1576:18;16020::0;1457:203:1;15969:20:0;;;;;-1:-1:-1;;;;;15969:20:0;;;16615:297;;;;;;:::i;:::-;;:::i;16529:81::-;;;;;;:::i;:::-;;:::i;15993:21::-;;;;;-1:-1:-1;;;;;15993:21:0;;;17287:102;;;;;;:::i;:::-;-1:-1:-1;;;;;17367:17:0;17346:7;17367:17;;;:8;:17;;;;;;;17287:102;16443:81;17772:5;;-1:-1:-1;;;;;17772:5:0;17758:10;:19;17750:38;;;;-1:-1:-1;;;17750:38:0;;4425:2:1;17750:38:0;;;4407:21:1;4464:1;4444:18;;;4437:29;-1:-1:-1;;;4482:18:1;;;4475:36;4528:18;;17750:38:0;;;;;;;;;16503:5:::1;:16:::0;;-1:-1:-1;;;;;;16503:16:0::1;-1:-1:-1::0;;;;;16503:16:0;;;::::1;::::0;;;::::1;::::0;;16443:81::o;16917:365::-;16986:1;16977:6;:10;16969:30;;;;-1:-1:-1;;;16969:30:0;;3679:2:1;16969:30:0;;;3661:21:1;3718:1;3698:18;;;3691:29;-1:-1:-1;;;3736:18:1;;;3729:37;3783:18;;16969:30:0;3477:330:1;16969:30:0;17029:10;17020:20;;;;:8;:20;;;;;;17010:30;;17006:77;;-1:-1:-1;17066:10:0;17057:20;;;;:8;:20;;;;;;17006:77;17089:16;:14;:16::i;:::-;17127:6;17112:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;17147:10:0;17138:20;;;;:8;:20;;;;;:30;;17162:6;;17138:20;:30;;17162:6;;17138:30;:::i;:::-;;;;-1:-1:-1;;17182:3:0;;17175:44;;-1:-1:-1;;;;;17182:3:0;17200:10;17212:6;17175:24;:44::i;:::-;17231;;4703:25:1;;;17248:10:0;;17231:44;;4691:2:1;4676:18;17231:44:0;;;;;;;;16917:365;:::o;16615:297::-;16681:1;16672:6;:10;16664:30;;;;-1:-1:-1;;;16664:30:0;;3679:2:1;16664:30:0;;;3661:21:1;3718:1;3698:18;;;3691:29;-1:-1:-1;;;3736:18:1;;;3729:37;3783:18;;16664:30:0;3477:330:1;16664:30:0;16701:16;:14;:16::i;:::-;16739:6;16724:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;;16759:10:0;16750:20;;;;:8;:20;;;;;:30;;16774:6;;16750:20;:30;;16774:6;;16750:30;:::i;:::-;;;;-1:-1:-1;;16794:3:0;;16787:63;;-1:-1:-1;;;;;16794:3:0;16816:10;16836:4;16843:6;16787:28;:63::i;:::-;16862:43;;4703:25:1;;;16878:10:0;;16862:43;;4691:2:1;4676:18;16862:43:0;4557:177:1;16529:81:0;17772:5;;-1:-1:-1;;;;;17772:5:0;17758:10;:19;17750:38;;;;-1:-1:-1;;;17750:38:0;;4425:2:1;17750:38:0;;;4407:21:1;4464:1;4444:18;;;4437:29;-1:-1:-1;;;4482:18:1;;;4475:36;4528:18;;17750:38:0;4223:329:1;17750:38:0;16589:6:::1;:16:::0;;-1:-1:-1;;;;;;16589:16:0::1;-1:-1:-1::0;;;;;16589:16:0;;;::::1;::::0;;;::::1;::::0;;16529:81::o;17394:325::-;17459:6;;17451:34;;;-1:-1:-1;;;17451:34:0;;;;17434:14;;-1:-1:-1;;;;;17459:6:0;;17451:32;;:34;;;;;;;;;;;;;;17459:6;17451:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17434:51;;17495:9;17490:225;17514:6;17510:1;:10;17490:225;;;17560:6;;17552:29;;-1:-1:-1;;;17552:29:0;;;;;4703:25:1;;;17533:16:0;;-1:-1:-1;;;;;17560:6:0;;17552:26;;4676:18:1;;17552:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17621:6;;17613:39;;-1:-1:-1;;;17613:39:0;;-1:-1:-1;;;;;1621:32:1;;;17613:39:0;;;1603:51:1;17533:48:0;;-1:-1:-1;17587:23:0;;17621:6;;;;17613:29;;1576:18:1;;17613:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17658:51;;-1:-1:-1;;;17658:51:0;;17698:10;17658:51;;;1603::1;17587:65:0;;-1:-1:-1;;;;;;17658:39:0;;;;;1576:18:1;;17658:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17527:188;;17522:3;;;;;:::i;:::-;;;;17490:225;;;;17429:290;17394:325::o;11458:211::-;11602:58;;-1:-1:-1;;;;;2237:32:1;;11602:58:0;;;2219:51:1;2286:18;;;2279:34;;;11575:86:0;;11595:5;;-1:-1:-1;;;11625:23:0;2192:18:1;;11602:58:0;;;;-1:-1:-1;;11602:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;11602:58:0;-1:-1:-1;;;;;;11602:58:0;;;;;;;;;;11575:19;:86::i;:::-;11458:211;;;:::o;11677:248::-;11848:68;;-1:-1:-1;;;;;1923:15:1;;;11848:68:0;;;1905:34:1;1975:15;;1955:18;;;1948:43;2007:18;;;2000:34;;;11821:96:0;;11841:5;;-1:-1:-1;;;11871:27:0;1840:18:1;;11848:68:0;1665:375:1;11821:96:0;11677:248;;;;:::o;14031:716::-;14455:23;14481:69;14509:4;14481:69;;;;;;;;;;;;;;;;;14489:5;-1:-1:-1;;;;;14481:27:0;;;:69;;;;;:::i;:::-;14565:17;;14455:95;;-1:-1:-1;14565:21:0;14561:179;;14662:10;14651:30;;;;;;;;;;;;:::i;:::-;14643:85;;;;-1:-1:-1;;;14643:85:0;;4014:2:1;14643:85:0;;;3996:21:1;4053:2;4033:18;;;4026:30;4092:34;4072:18;;;4065:62;-1:-1:-1;;;4143:18:1;;;4136:40;4193:19;;14643:85:0;3812:406:1;6409:229:0;6546:12;6578:52;6600:6;6608:4;6614:1;6617:12;6578:21;:52::i;:::-;6571:59;;6409:229;;;;;;:::o;7529:510::-;7699:12;7757:5;7732:21;:30;;7724:81;;;;-1:-1:-1;;;7724:81:0;;2914:2:1;7724:81:0;;;2896:21:1;2953:2;2933:18;;;2926:30;2992:34;2972:18;;;2965:62;-1:-1:-1;;;3043:18:1;;;3036:36;3089:19;;7724:81:0;2712:402:1;7724:81:0;3926:20;;7816:60;;;;-1:-1:-1;;;7816:60:0;;3321:2:1;7816:60:0;;;3303:21:1;3360:2;3340:18;;;3333:30;3399:31;3379:18;;;3372:59;3448:18;;7816:60:0;3119:353:1;7816:60:0;7890:12;7904:23;7931:6;-1:-1:-1;;;;;7931:11:0;7950:5;7957:4;7931:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7889:73;;;;7980:51;7997:7;8006:10;8018:12;7980:16;:51::i;:::-;7973:58;7529:510;-1:-1:-1;;;;;;;7529:510:0:o;10215:712::-;10365:12;10394:7;10390:530;;;-1:-1:-1;10425:10:0;10418:17;;10390:530;10539:17;;:21;10535:374;;10737:10;10731:17;10798:15;10785:10;10781:2;10777:19;10770:44;10535:374;10880:12;10873:20;;-1:-1:-1;;;10873:20:0;;;;;;;;:::i;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;181:9;168:23;200:31;225:5;200:31;:::i;266:251::-;336:6;389:2;377:9;368:7;364:23;360:32;357:52;;;405:1;402;395:12;357:52;437:9;431:16;456:31;481:5;456:31;:::i;522:277::-;589:6;642:2;630:9;621:7;617:23;613:32;610:52;;;658:1;655;648:12;610:52;690:9;684:16;743:5;736:13;729:21;722:5;719:32;709:60;;765:1;762;755:12;804:180;863:6;916:2;904:9;895:7;891:23;887:32;884:52;;;932:1;929;922:12;884:52;-1:-1:-1;955:23:1;;804:180;-1:-1:-1;804:180:1:o;989:184::-;1059:6;1112:2;1100:9;1091:7;1087:23;1083:32;1080:52;;;1128:1;1125;1118:12;1080:52;-1:-1:-1;1151:16:1;;989:184;-1:-1:-1;989:184:1:o;1178:274::-;1307:3;1345:6;1339:13;1361:53;1407:6;1402:3;1395:4;1387:6;1383:17;1361:53;:::i;:::-;1430:16;;;;;1178:274;-1:-1:-1;;1178:274:1:o;2324:383::-;2473:2;2462:9;2455:21;2436:4;2505:6;2499:13;2548:6;2543:2;2532:9;2528:18;2521:34;2564:66;2623:6;2618:2;2607:9;2603:18;2598:2;2590:6;2586:15;2564:66;:::i;:::-;2691:2;2670:15;-1:-1:-1;;2666:29:1;2651:45;;;;2698:2;2647:54;;2324:383;-1:-1:-1;;2324:383:1:o;4739:128::-;4779:3;4810:1;4806:6;4803:1;4800:13;4797:39;;;4816:18;;:::i;:::-;-1:-1:-1;4852:9:1;;4739:128::o;4872:125::-;4912:4;4940:1;4937;4934:8;4931:34;;;4945:18;;:::i;:::-;-1:-1:-1;4982:9:1;;4872:125::o;5002:258::-;5074:1;5084:113;5098:6;5095:1;5092:13;5084:113;;;5174:11;;;5168:18;5155:11;;;5148:39;5120:2;5113:10;5084:113;;;5215:6;5212:1;5209:13;5206:48;;;-1:-1:-1;;5250:1:1;5232:16;;5225:27;5002:258::o;5265:135::-;5304:3;-1:-1:-1;;5325:17:1;;5322:43;;;5345:18;;:::i;:::-;-1:-1:-1;5392:1:1;5381:13;;5265:135::o;5405:127::-;5466:10;5461:3;5457:20;5454:1;5447:31;5497:4;5494:1;5487:15;5521:4;5518:1;5511:15;5537:131;-1:-1:-1;;;;;5612:31:1;;5602:42;;5592:70;;5658:1;5655;5648:12;5592:70;5537:131;:::o

ipfs://ad4cdfd3564cb9272f06f5b67a1847d6d406e7fec217f7dfb17849f6c706b34e