Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import "./BaseImmutableAdminUpgradeabilityProxy.sol";
import "../../../dependencies/openzeppelin/upgradeability/InitializableUpgradeabilityProxy.sol";

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import "../../../dependencies/openzeppelin/upgradeability/BaseUpgradeabilityProxy.sol";

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import "./Proxy.sol";
import "@openzeppelin/contracts/utils/Address.sol";

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

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

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.12;

import "./BaseUpgradeabilityProxy.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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
     * ====
     *
     * [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 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);
        }
    }
}

{
  "metadata": {
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• 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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

000000000000000000000000091d52cace1edc5527c99cdcfa6937c1635330e4

-----Decoded View---------------
Arg [0] : admin (address): 0x091d52CacE1edc5527C99cDCFA6937C1635330E4

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000091d52cace1edc5527c99cdcfa6937c1635330e4

344:433:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;491:11:2;:9;:11::i;:::-;344:433:4;1423:100:3;;;;;;;;;;-1:-1:-1;1423:100:3;;;;;:::i;:::-;;:::i;2030:215::-;;;;;;:::i;:::-;;:::i;1143:102::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1240:55:6;;;1222:74;;1210:2;1195:18;1143:102:3;;;;;;;850:348:1;;;;;;:::i;:::-;;:::i;993:81:3:-;;;;;;;;;;;;;:::i;1991:85:2:-;2025:15;:13;:15::i;:::-;2044:28;2054:17;825:66:0;1171:11;;1005:184;2054:17:2;2044:9;:28::i;:::-;1991:85::o;1423:100:3:-;865:10;-1:-1:-1;;;;;879:5:3;865:19;;861:63;;;1490:29:::1;1501:17;1490:10;:29::i;:::-;1423:100:::0;:::o;861:63::-;908:11;:9;:11::i;2030:215::-;865:10;-1:-1:-1;;;;;879:5:3;865:19;;861:63;;;2133:29:::1;2144:17;2133:10;:29::i;:::-;2167:12;2185:17;-1:-1:-1::0;;;;;2185:30:3::1;2216:4;;2185:36;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2166:55;;;2233:7;2225:16;;;::::0;::::1;;2129:116;2030:215:::0;;;:::o;861:63::-;908:11;:9;:11::i;:::-;2030:215;;;:::o;1143:102::-;1195:16;865:10;-1:-1:-1;;;;;879:5:3;865:19;;861:63;;;-1:-1:-1;825:66:0;1171:11;;1143:102:3:o;861:63::-;908:11;:9;:11::i;:::-;1143:102;:::o;850:348:1:-;962:1;933:17;825:66:0;1171:11;;1005:184;933:17:1;-1:-1:-1;;;;;933:31:1;;925:40;;;;;;1007:54;1060:1;1015:41;1007:54;:::i;:::-;825:66:0;976:86:1;969:94;;;;:::i;:::-;1067:26;1086:6;1067:18;:26::i;:::-;1101:12;;:16;1097:98;;1125:12;1143:6;-1:-1:-1;;;;;1143:19:1;1163:5;1143:26;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1124:45;;;1182:7;1174:16;;;;;1097:98;850:348;;:::o;993:81:3:-;1036:16;865:10;-1:-1:-1;;;;;879:5:3;865:19;;861:63;;;-1:-1:-1;1065:5:3::1;1143:102:::0;:::o;625:150:4:-;718:53;:51;:53::i;912:742:2:-;1229:14;1226:1;1223;1210:34;1416:1;1413;1397:14;1394:1;1378:14;1371:5;1358:60;1474:16;1471:1;1468;1453:38;1503:6;1552:45;;;;1625:16;1622:1;1615:27;1552:45;1575:16;1572:1;1565:27;1319:137:0;1379:37;1398:17;1379:18;:37::i;:::-;1425:27;;-1:-1:-1;;;;;1425:27:0;;;;;;;;1319:137;:::o;1588:302::-;-1:-1:-1;;;;;1465:19:5;;;1656:109:0;;;;-1:-1:-1;;;1656:109:0;;3878:2:6;1656:109:0;;;3860:21:6;3917:2;3897:18;;;3890:30;3956:34;3936:18;;;3929:62;4027:29;4007:18;;;4000:57;4074:19;;1656:109:0;;;;;;;;;825:66;1852:31;1588:302::o;2316:166:3:-;2379:10;-1:-1:-1;;;;;2393:5:3;2379:19;;;2371:82;;;;-1:-1:-1;;;2371:82:3;;4306:2:6;2371:82:3;;;4288:21:6;4345:2;4325:18;;;4318:30;4384:34;4364:18;;;4357:62;4455:20;4435:18;;;4428:48;4493:19;;2371:82:3;4104:414:6;14:196;82:20;;-1:-1:-1;;;;;131:54:6;;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:6: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::-;-1:-1:-1;;;1356:1:6;1349:88;1456:4;1453:1;1446:15;1480:4;1477:1;1470:15;1496:995;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;:::-;2077:2;2071:9;2045:2;2131:13;;-1:-1:-1;;2127:22:6;;;2151:2;2123:31;2119:40;2107:53;;;2175:18;;;2195:22;;;2172:46;2169:72;;;2221:18;;:::i;:::-;2261:10;2257:2;2250:22;2296:2;2288:6;2281:18;2336:7;2331:2;2326;2322;2318:11;2314:20;2311:33;2308:53;;;2357:1;2354;2347:12;2308:53;2413:2;2408;2404;2400:11;2395:2;2387:6;2383:15;2370:46;2458:1;2453:2;2448;2440:6;2436:15;2432:24;2425:35;2479:6;2469:16;;;;;;;1496:995;;;;;:::o;2496:271::-;2679:6;2671;2666:3;2653:33;2635:3;2705:16;;2730:13;;;2705:16;2496:271;-1:-1:-1;2496:271:6:o;2772:279::-;2812:4;2840:1;2837;2834:8;2831:188;;;-1:-1:-1;;;2872:1:6;2865:88;2976:4;2973:1;2966:15;3004:4;3001:1;2994:15;2831:188;-1:-1:-1;3036:9:6;;2772:279::o;3056:184::-;-1:-1:-1;;;3105:1:6;3098:88;3205:4;3202:1;3195:15;3229:4;3226:1;3219:15;3245:426;3374:3;3412:6;3406:13;3437:1;3447:129;3461:6;3458:1;3455:13;3447:129;;;3559:4;3543:14;;;3539:25;;3533:32;3520:11;;;3513:53;3476:12;3447:129;;;3594:6;3591:1;3588:13;3585:48;;;3629:1;3620:6;3615:3;3611:16;3604:27;3585:48;-1:-1:-1;3649:16:6;;;;;3245:426;-1:-1:-1;;3245:426:6:o

ipfs://42e28d728a899bce17dd811b4fea918cccc026ea931fafa4186c5407bbe6da08