Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
•    - function _implementation()
•    - function _delegate(address implementa ...
•    - function _willFallback()
•    - function _fallback()
•  contract BaseUpgradeabilityProxy i ...
•    - function _implementation()
•    - function _upgradeTo(address newImplem ...
•    - function _setImplementation(address n ...
•  contract InitializableUpgradeabili ...
•    - function initialize(address _logic, b ...
•  contract BaseImmutableAdminUpgrade ...
•    - function admin()
•    - function implementation()
•    - function upgradeTo(address newImpleme ...
•    - function upgradeToAndCall(address new ...
•    - function _willFallback()
•  contract InitializableImmutableAdm ... *
•    - function _willFallback()

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-10-31
*/

// SPDX-License-Identifier: AGPL-3.0 AND MIT AND agpl-3.0

// File @openzeppelin/contracts/utils/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (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
	 *
	 * Furthermore, `isContract` will also return true if the target contract within
	 * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
	 * which only has an effect at the end of a transaction.
	 * ====
	 *
	 * [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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
		(bool success, bytes memory returndata) = target.call{value: value}(data);
		return verifyCallResultFromTarget(target, 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) {
		(bool success, bytes memory returndata) = target.staticcall(data);
		return verifyCallResultFromTarget(target, 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) {
		(bool success, bytes memory returndata) = target.delegatecall(data);
		return verifyCallResultFromTarget(target, success, returndata, errorMessage);
	}

	/**
	 * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
	 * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
	 *
	 * _Available since v4.8._
	 */
	function verifyCallResultFromTarget(
		address target,
		bool success,
		bytes memory returndata,
		string memory errorMessage
	) internal view returns (bytes memory) {
		if (success) {
			if (returndata.length == 0) {
				// only check isContract if the call was successful and the return data is empty
				// otherwise we already know that it was a contract
				require(isContract(target), "Address: call to non-contract");
			}
			return returndata;
		} else {
			_revert(returndata, errorMessage);
		}
	}

	/**
	 * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
	 * revert reason or 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 {
			_revert(returndata, errorMessage);
		}
	}

	function _revert(bytes memory returndata, string memory errorMessage) private pure {
		// 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
			/// @solidity memory-safe-assembly
			assembly {
				let returndata_size := mload(returndata)
				revert(add(32, returndata), returndata_size)
			}
		} else {
			revert(errorMessage);
		}
	}
}

// File contracts/dependencies/openzeppelin/upgradeability/Proxy.sol

// Original license: SPDX_License_Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @title Proxy
 * @dev Implements delegation of calls to other contracts, with proper
 * forwarding of return values and bubbling of failures.
 * It defines a fallback function that delegates all calls to the address
 * returned by the abstract _implementation() internal function.
 */
abstract contract Proxy {
	/**
	 * @dev Fallback function.
	 * Implemented entirely in `_fallback`.
	 */
	fallback() external payable {
		_fallback();
	}

	/**
	 * @return The Address of the implementation.
	 */
	function _implementation() internal view virtual returns (address);

	/**
	 * @dev Delegates execution to an implementation contract.
	 * This is a low level function that doesn't return to its internal call site.
	 * It will return to the external caller whatever the implementation returns.
	 * @param implementation Address to delegate.
	 */
	function _delegate(address implementation) internal {
		//solium-disable-next-line
		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 Function that is run as the first thing in the fallback function.
	 * Can be redefined in derived contracts to add functionality.
	 * Redefinitions must call super._willFallback().
	 */
	function _willFallback() internal virtual {}

	/**
	 * @dev fallback implementation.
	 * Extracted to enable manual triggering.
	 */
	function _fallback() internal {
		_willFallback();
		_delegate(_implementation());
	}
}

// File contracts/dependencies/openzeppelin/upgradeability/BaseUpgradeabilityProxy.sol

// Original license: SPDX_License_Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @title BaseUpgradeabilityProxy
 * @dev This contract implements a proxy that allows to change the
 * implementation address to which it will delegate.
 * Such a change is called an implementation upgrade.
 */
contract BaseUpgradeabilityProxy is Proxy {
	/**
	 * @dev Emitted when the implementation is upgraded.
	 * @param implementation Address of the new implementation.
	 */
	event Upgraded(address indexed implementation);

	/**
	 * @dev Storage slot with the address of the current implementation.
	 * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
	 * validated in the constructor.
	 */
	bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

	/**
	 * @dev Returns the current implementation.
	 * @return impl Address of the current implementation
	 */
	function _implementation() internal view override returns (address impl) {
		bytes32 slot = IMPLEMENTATION_SLOT;
		//solium-disable-next-line
		assembly {
			impl := sload(slot)
		}
	}

	/**
	 * @dev Upgrades the proxy to a new implementation.
	 * @param newImplementation Address of the new implementation.
	 */
	function _upgradeTo(address newImplementation) internal {
		_setImplementation(newImplementation);
		emit Upgraded(newImplementation);
	}

	/**
	 * @dev Sets the implementation address of the proxy.
	 * @param newImplementation Address of the new implementation.
	 */
	function _setImplementation(address newImplementation) internal {
		require(Address.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");

		bytes32 slot = IMPLEMENTATION_SLOT;

		//solium-disable-next-line
		assembly {
			sstore(slot, newImplementation)
		}
	}
}

// File contracts/dependencies/openzeppelin/upgradeability/InitializableUpgradeabilityProxy.sol

// Original license: SPDX_License_Identifier: agpl-3.0
pragma solidity 0.8.12;

/**
 * @title InitializableUpgradeabilityProxy
 * @dev Extends BaseUpgradeabilityProxy with an initializer for initializing
 * implementation and init data.
 */
contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy {
	/**
	 * @dev Contract initializer.
	 * @param _logic Address of the initial implementation.
	 * @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
	 * It should include the signature and the parameters of the function to be called, as described in
	 * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
	 * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
	 */
	function initialize(address _logic, bytes memory _data) public payable {
		require(_implementation() == address(0));
		assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
		_setImplementation(_logic);
		if (_data.length > 0) {
			(bool success, ) = _logic.delegatecall(_data);
			require(success);
		}
	}
}

// File contracts/lending/libraries/aave-upgradeability/BaseImmutableAdminUpgradeabilityProxy.sol

// Original license: SPDX_License_Identifier: AGPL-3.0
pragma solidity 0.8.12;

/**
 * @title BaseImmutableAdminUpgradeabilityProxy
 * @author Aave, inspired by the OpenZeppelin upgradeability proxy pattern
 * @dev This contract combines an upgradeability proxy with an authorization
 * mechanism for administrative tasks. The admin role is stored in an immutable, which
 * helps saving transactions costs
 * All external functions in this contract must be guarded by the
 * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
 * feature proposal that would enable this to be done automatically.
 */
contract BaseImmutableAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
	address immutable ADMIN;

	constructor(address _admin) {
		ADMIN = _admin;
	}

	modifier ifAdmin() {
		if (msg.sender == ADMIN) {
			_;
		} else {
			_fallback();
		}
	}

	/**
	 * @return _address The address of the proxy admin.
	 */
	function admin() external ifAdmin returns (address _address) {
		return ADMIN;
	}

	/**
	 * @return _address The address of the implementation.
	 */
	function implementation() external ifAdmin returns (address _address) {
		return _implementation();
	}

	/**
	 * @dev Upgrade the backing implementation of the proxy.
	 * Only the admin can call this function.
	 * @param newImplementation Address of the new implementation.
	 */
	function upgradeTo(address newImplementation) external ifAdmin {
		_upgradeTo(newImplementation);
	}

	/**
	 * @dev Upgrade the backing implementation of the proxy and call a function
	 * on the new implementation.
	 * This is useful to initialize the proxied contract.
	 * @param newImplementation Address of the new implementation.
	 * @param data Data to send as msg.data in the low level call.
	 * It should include the signature and the parameters of the function to be called, as described in
	 * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
	 */
	function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
		_upgradeTo(newImplementation);
		(bool success, ) = newImplementation.delegatecall(data);
		require(success);
	}

	/**
	 * @dev Only fall back when the sender is not the admin.
	 */
	function _willFallback() internal virtual override {
		require(msg.sender != ADMIN, "Cannot call fallback function from the proxy admin");
		super._willFallback();
	}
}

// File contracts/lending/libraries/aave-upgradeability/InitializableImmutableAdminUpgradeabilityProxy.sol

// Original license: SPDX_License_Identifier: AGPL-3.0
pragma solidity 0.8.12;

/**
 * @title InitializableAdminUpgradeabilityProxy
 * @dev Extends BaseAdminUpgradeabilityProxy with an initializer function
 */
contract InitializableImmutableAdminUpgradeabilityProxy is
	BaseImmutableAdminUpgradeabilityProxy,
	InitializableUpgradeabilityProxy
{
	constructor(address admin) BaseImmutableAdminUpgradeabilityProxy(admin) {}

	/**
	 * @dev Only fall back when the sender is not the admin.
	 */
	function _willFallback() internal override(BaseImmutableAdminUpgradeabilityProxy, Proxy) {
		BaseImmutableAdminUpgradeabilityProxy._willFallback();
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"_address","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"_address","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}]

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

17285:445:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9428:11;:9;:11::i;:::-;17285:445;15867:102;;;;;;;;;;-1:-1:-1;15867:102:0;;;;;:::i;:::-;;:::i;16487:219::-;;;;;;:::i;:::-;;:::i;15578:104::-;;;;;;;;;;;;;:::i;:::-;;;1252:42:1;1240:55;;;1222:74;;1210:2;1195:18;15578:104:0;;;;;;;14004:356;;;;;;:::i;:::-;;:::i;15421:83::-;;;;;;;;;;;;;:::i;10979:88::-;11014:15;:13;:15::i;:::-;11034:28;11044:17;11953:66;12309:11;;12139:190;11044:17;11034:9;:28::i;:::-;10979:88::o;15867:102::-;15283:10;:19;15297:5;15283:19;;15279:67;;;15935:29:::1;15946:17;15935:10;:29::i;:::-;15867:102:::0;:::o;15279:67::-;15329:11;:9;:11::i;16487:219::-;15283:10;:19;15297:5;15283:19;;15279:67;;;16591:29:::1;16602:17;16591:10;:29::i;:::-;16626:12;16644:17;:30;;16675:4;;16644:36;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16625:55;;;16693:7;16685:16;;;::::0;::::1;;16586:120;16487:219:::0;;;:::o;15279:67::-;15329:11;:9;:11::i;:::-;16487:219;;;:::o;15578:104::-;15630:16;15283:10;:19;15297:5;15283:19;;15279:67;;;-1:-1:-1;11953:66:0;12309:11;;15578:104::o;15279:67::-;15329:11;:9;:11::i;:::-;15578:104;:::o;14004:356::-;14117:1;14088:17;11953:66;12309:11;;12139:190;14088:17;:31;;;14080:40;;;;;;14163:54;14216:1;14171:41;14163:54;:::i;:::-;11953:66;14132:86;14125:94;;;;:::i;:::-;14224:26;14243:6;14224:18;:26::i;:::-;14259:12;;:16;14255:101;;14284:12;14302:6;:19;;14322:5;14302:26;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14283:45;;;14342:7;14334:16;;;;;14255:101;14004:356;;:::o;15421:83::-;15464:16;15283:10;:19;15297:5;15283:19;;15279:67;;;-1:-1:-1;15494:5:0::1;15578:104:::0;:::o;17575:152::-;17669:53;:51;:53::i;9863:766::-;10186:14;10183:1;10180;10167:34;10377:1;10374;10358:14;10355:1;10339:14;10332:5;10319:60;10438:16;10435:1;10432;10417:38;10469:6;10520:47;;;;10597:16;10594:1;10587:27;10520:47;10544:16;10541:1;10534:27;12465:140;12526:37;12545:17;12526:18;:37::i;:::-;12573:27;;;;;;;;;;;12465:140;:::o;12743:311::-;1768:19;;;;12812:109;;;;;;;3937:2:1;12812:109:0;;;3919:21:1;3976:2;3956:18;;;3949:30;4015:34;3995:18;;;3988:62;4086:29;4066:18;;;4059:57;4133:19;;12812:109:0;;;;;;;;;11953:66;13014:31;12743:311::o;16782:169::-;16846:10;:19;16860:5;16846:19;;;16838:82;;;;;;;4365:2:1;16838:82:0;;;4347:21:1;4404:2;4384:18;;;4377:30;4443:34;4423:18;;;4416:62;4514:20;4494:18;;;4487:48;4552:19;;16838:82:0;4163:414:1;14:196;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;:::-;356:39;215:186;-1:-1:-1;;;215:186:1:o;406:665::-;485:6;493;501;554:2;542:9;533:7;529:23;525:32;522:52;;;570:1;567;560:12;522:52;593:29;612:9;593:29;:::i;:::-;583:39;;673:2;662:9;658:18;645:32;696:18;737:2;729:6;726:14;723:34;;;753:1;750;743:12;723:34;791:6;780:9;776:22;766:32;;836:7;829:4;825:2;821:13;817:27;807:55;;858:1;855;848:12;807:55;898:2;885:16;924:2;916:6;913:14;910:34;;;940:1;937;930:12;910:34;985:7;980:2;971:6;967:2;963:15;959:24;956:37;953:57;;;1006:1;1003;996:12;953:57;1037:2;1033;1029:11;1019:21;;1059:6;1049:16;;;;;406:665;;;;;:::o;1307:184::-;1359:77;1356:1;1349:88;1456:4;1453:1;1446:15;1480:4;1477:1;1470:15;1496:1054;1573:6;1581;1634:2;1622:9;1613:7;1609:23;1605:32;1602:52;;;1650:1;1647;1640:12;1602:52;1673:29;1692:9;1673:29;:::i;:::-;1663:39;;1753:2;1742:9;1738:18;1725:32;1776:18;1817:2;1809:6;1806:14;1803:34;;;1833:1;1830;1823:12;1803:34;1871:6;1860:9;1856:22;1846:32;;1916:7;1909:4;1905:2;1901:13;1897:27;1887:55;;1938:1;1935;1928:12;1887:55;1974:2;1961:16;1996:2;1992;1989:10;1986:36;;;2002:18;;:::i;:::-;2136:2;2130:9;2198:4;2190:13;;2041:66;2186:22;;;2210:2;2182:31;2178:40;2166:53;;;2234:18;;;2254:22;;;2231:46;2228:72;;;2280:18;;:::i;:::-;2320:10;2316:2;2309:22;2355:2;2347:6;2340:18;2395:7;2390:2;2385;2381;2377:11;2373:20;2370:33;2367:53;;;2416:1;2413;2406:12;2367:53;2472:2;2467;2463;2459:11;2454:2;2446:6;2442:15;2429:46;2517:1;2512:2;2507;2499:6;2495:15;2491:24;2484:35;2538:6;2528:16;;;;;;;1496:1054;;;;;:::o;2555:271::-;2738:6;2730;2725:3;2712:33;2694:3;2764:16;;2789:13;;;2764:16;2555:271;-1:-1:-1;2555:271:1:o;2831:279::-;2871:4;2899:1;2896;2893:8;2890:188;;;2934:77;2931:1;2924:88;3035:4;3032:1;3025:15;3063:4;3060:1;3053:15;2890:188;-1:-1:-1;3095:9:1;;2831:279::o;3115:184::-;3167:77;3164:1;3157:88;3264:4;3261:1;3254:15;3288:4;3285:1;3278:15;3304:426;3433:3;3471:6;3465:13;3496:1;3506:129;3520:6;3517:1;3514:13;3506:129;;;3618:4;3602:14;;;3598:25;;3592:32;3579:11;;;3572:53;3535:12;3506:129;;;3653:6;3650:1;3647:13;3644:48;;;3688:1;3679:6;3674:3;3670:16;3663:27;3644:48;-1:-1:-1;3708:16:1;;;;;3304:426;-1:-1:-1;;3304:426:1:o

ipfs://b341a2955f497c626751626350ed7a4e674c76a846828e641fe7a2ed5226afd8