Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60a06040 | 15587052 | 715 days ago | IN | 0 ETH | 0.02945981 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
MainPool
Compiler Version
v0.8.11+commit.d7f03943
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-10-06 */ // Sources flattened with hardhat v2.9.3 https://hardhat.org // File @openzeppelin/contracts-upgradeable/utils/[email protected] // SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @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 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 @openzeppelin/contracts-upgradeable/proxy/utils/[email protected] // License: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.0; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() initializer {} * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { // If the contract is initializing we ignore whether _initialized is set in order to support multiple // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the // contract may have been reentered. require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} modifier, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } function _isConstructor() private view returns (bool) { return !AddressUpgradeable.isContract(address(this)); } } // File @openzeppelin/contracts-upgradeable/interfaces/[email protected] // License: MIT // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.0; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822ProxiableUpgradeable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); } // File @openzeppelin/contracts-upgradeable/proxy/beacon/[email protected] // License: MIT // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeaconUpgradeable { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function implementation() external view returns (address); } // File @openzeppelin/contracts-upgradeable/utils/[email protected] // License: MIT // OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol) pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ``` * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ */ library StorageSlotUpgradeable { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } } // File @openzeppelin/contracts-upgradeable/proxy/ERC1967/[email protected] // License: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol) pragma solidity ^0.8.2; /** * @dev This abstract contract provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. * * _Available since v4.1._ * * @custom:oz-upgrades-unsafe-allow delegatecall */ abstract contract ERC1967UpgradeUpgradeable is Initializable { function __ERC1967Upgrade_init() internal onlyInitializing { } function __ERC1967Upgrade_init_unchained() internal onlyInitializing { } // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; /** * @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 Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Returns the current implementation address. */ function _getImplementation() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the EIP1967 implementation slot. */ function _setImplementation(address newImplementation) private { require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall( address newImplementation, bytes memory data, bool forceCall ) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { _functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS( address newImplementation, bytes memory data, bool forceCall ) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Emitted when the beacon is upgraded. */ event BeaconUpgraded(address indexed beacon); /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall( address newBeacon, bytes memory data, bool forceCall ) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); } } /** * @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) private returns (bytes memory) { require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed"); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File @openzeppelin/contracts-upgradeable/proxy/utils/[email protected] // License: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.0; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. * * _Available since v4.1._ */ abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable { function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment address private immutable __self = address(this); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { require(address(this) != __self, "Function must be called through delegatecall"); require(_getImplementation() == __self, "Function must be called through active proxy"); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); _; } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate that the this implementation remains valid after an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual override notDelegated returns (bytes32) { return _IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeTo(address newImplementation) external virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data, true); } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeTo} and {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal override onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File @openzeppelin/contracts-upgradeable/utils/math/[email protected] // License: MIT // OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMathUpgradeable { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File @openzeppelin/contracts-upgradeable/utils/[email protected] // License: MIT // 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 ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File @openzeppelin/contracts-upgradeable/access/[email protected] // License: MIT // 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 OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _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); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File @openzeppelin/contracts-upgradeable/token/ERC721/[email protected] // License: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721ReceiverUpgradeable { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File contracts/interfaces/IERC20Receiver.sol // License: MIT pragma solidity 0.8.11; /** * @title ERC20 token receiver interface * * @dev Interface for any contract that wants to support safe transfers * from ERC20 token smart contracts. * @dev Inspired by ERC721 and ERC223 token standards * * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md * @dev See https://github.com/ethereum/EIPs/issues/223 * @author Basil Gorin * Adapted for Syn City by Superpower Labs */ interface IERC20Receiver { /** * @notice Handle the receipt of a ERC20 token(s) * @dev The ERC20 smart contract calls this function on the recipient * after a successful transfer (`safeTransferFrom`). * This function MAY throw to revert and reject the transfer. * Return of other than the magic value MUST result in the transaction being reverted. * @notice The contract address is always the message sender. * A wallet/broker/auction application MUST implement the wallet interface * if it will accept safe transfers. * @param _operator The address which called `safeTransferFrom` function * @param _from The address which previously owned the token * @param _value amount of tokens which is being transferred * @param _data additional data with no specified format * @return `bytes4(keccak256("onERC20Received(address,address,uint256,bytes)"))` unless throwing */ function onERC20Received( address _operator, address _from, uint256 _value, bytes calldata _data ) external returns (bytes4); } // File contracts/token/TokenReceiver.sol // License: MIT pragma solidity 0.8.11; //import "hardhat/console.sol"; contract TokenReceiver is IERC20Receiver, IERC721ReceiverUpgradeable { function onERC20Received( address, address, uint256, bytes calldata ) external pure override returns (bytes4) { return this.onERC20Received.selector; } function onERC721Received( address, address, uint256, bytes calldata ) public pure override returns (bytes4) { return this.onERC721Received.selector; } } // File contracts/interfaces/IMainUser.sol // License: MIT pragma solidity 0.8.11; interface IMainUser { event DepositSaved(address indexed user, uint16 indexed mainIndex); event DepositUnlocked(address indexed user, uint16 indexed mainIndex); struct Deposit { // @dev token type (0: sSYNR, 1: SYNR, 2: SYNR Pass... uint8 tokenType; // @dev locking period - from uint32 lockedFrom; // @dev locking period - until uint32 lockedUntil; // @dev token amount staked // SYNR maxTokenSupply is 10 billion * 18 decimals = 1e28 // which is less type(uint96).max (~79e28) uint96 tokenAmountOrID; uint32 unlockedAt; uint16 otherChain; // since the process is asyncronous, the same deposit can be at a different mainIndex // on the main net and on the sidechain. uint16 mainIndex; // available space for an extra variable uint24 extra; } /// @dev Data structure representing token holder using a pool struct User { // @dev Total staked SYNR amount uint96 synrAmount; // @dev Total passes staked uint16 passAmount; Deposit[] deposits; } } // File contracts/interfaces/IMainPool.sol // License: MIT pragma solidity 0.8.11; // Author: Francesco Sullo <[email protected]> // (c) 2022+ SuperPower Labs Inc. interface IMainPool is IMainUser { event PoolInitiated(uint16 minimumLockupTime, uint16 earlyUnstakePenalty); event PoolConfUpdated(uint16 minimumLockupTime, uint16 earlyUnstakePenalty); event PoolPaused(bool isPaused); event BridgeSet(address bridge); event BridgeRemoved(address bridge); event ImplementationUpgraded(address newImplementation); struct Conf { uint8 status; uint16 minimumLockupTime; uint16 maximumLockupTime; uint16 earlyUnstakePenalty; // TVL uint16 passAmount; uint96 synrAmount; // reserved for future variables uint32 reserved1; uint32 reserved2; uint24 reserved3; } function setBridge(address bridge_, bool active) external; function getDepositByIndex(address user, uint256 index) external view returns (Deposit memory); function getDepositsLength(address user) external view returns (uint256); function initPool(uint16 minimumLockupTime_, uint16 earlyUnstakePenalty_) external; function updateConf(uint16 minimumLockupTime_, uint16 earlyUnstakePenalty_) external; function getVestedPercentage( uint256 when, uint256 lockedFrom, uint256 lockedUntil ) external view returns (uint256); function calculatePenaltyForEarlyUnstake(uint256 when, IMainPool.Deposit memory deposit) external view returns (uint256); function withdrawSSynr(uint256 amount, address to) external; function withdrawPenalties(uint256 amount, address to) external; function stake( address user, uint256 payload, uint16 recipientChain ) external returns (uint256); function unstake( address user, uint256 tokenType, uint256 lockedFrom, uint256 lockedUntil, uint256 mainIndex, uint256 tokenAmountOrID ) external; function pausePool(bool paused) external; function validateInput( uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID ) external pure returns (bool); function deserializeInput(uint256 payload) external pure returns ( uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID ); function getIndexFromPayload(uint256 payload) external pure returns (uint256); } // File contracts/interfaces/ISyndicateERC20.sol // License: MIT pragma solidity 0.8.11; interface ISyndicateERC20 { function safeTransferFrom( address _from, address _to, uint256 _value, bytes memory _data ) external; } // File contracts/interfaces/ISyntheticSyndicateERC20.sol // License: MIT pragma solidity 0.8.11; interface ISyntheticSyndicateERC20 { function balanceOf(address owner) external view returns (uint256); function approve(address spender, uint256 amount) external; function isOperatorInRole(address operator, uint256 required) external view returns (bool); function transferFrom( address to, address receiver, uint256 tokenId ) external; } // File contracts/interfaces/IERC721Minimal.sol // License: MIT pragma solidity 0.8.11; // Author: Francesco Sullo <[email protected]> // Superpower Labs / Syn City interface IERC721Minimal { function safeTransferFrom( address to, address receiver, uint256 tokenId ) external; } // File contracts/utils/Constants.sol // License: MIT pragma solidity 0.8.11; // Author: Francesco Sullo <[email protected]> // (c) 2022+ SuperPower Labs Inc. contract Constants { uint8 public constant S_SYNR_SWAP = 1; uint8 public constant SYNR_STAKE = 2; uint8 public constant SYNR_PASS_STAKE_FOR_BOOST = 3; uint8 public constant SYNR_PASS_STAKE_FOR_SEEDS = 4; uint8 public constant BLUEPRINT_STAKE_FOR_BOOST = 5; uint8 public constant BLUEPRINT_STAKE_FOR_SEEDS = 6; uint256[50] private __gap; } // File contracts/utils/Versionable.sol // License: MIT pragma solidity 0.8.11; // Author: Francesco Sullo <[email protected]> // (c) 2022+ SuperPower Labs Inc. contract Versionable { function version() external pure virtual returns (uint256) { return 1; } } // File contracts/pool/MainPool.sol // License: MIT pragma solidity 0.8.11; // Author: Francesco Sullo <[email protected]> // (c) 2022+ SuperPower Labs Inc. //import "hardhat/console.sol"; contract MainPool is IMainPool, Versionable, Constants, TokenReceiver, Initializable, OwnableUpgradeable, UUPSUpgradeable { using AddressUpgradeable for address; using SafeMathUpgradeable for uint256; // users and deposits mapping(address => User) public users; Conf public conf; ISyndicateERC20 public synr; ISyntheticSyndicateERC20 public sSynr; IERC721Minimal public pass; uint256 public penalties; mapping(address => bool) public bridges; modifier onlyBridge() { require(bridges[_msgSender()], "MainPool: forbidden"); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor() initializer {} function initialize( address synr_, address sSynr_, address pass_ ) public initializer { // solhint-disable-next-line __Ownable_init(); require(synr_.isContract(), "synr_ not a contract"); require(sSynr_.isContract(), "sSynr_ not a contract"); require(pass_.isContract(), "pass_ not a contract"); synr = ISyndicateERC20(synr_); sSynr = ISyntheticSyndicateERC20(sSynr_); pass = IERC721Minimal(pass_); } function _authorizeUpgrade(address newImplementation) internal virtual override onlyOwner { emit ImplementationUpgraded(newImplementation); } function _updateTvl( uint256 tokenType, uint256 tokenAmount, bool increase ) internal { if (increase) { if (tokenType == SYNR_STAKE) { conf.synrAmount += uint96(tokenAmount); } else if (tokenType == SYNR_PASS_STAKE_FOR_BOOST || tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { conf.passAmount++; } } else { if (tokenType == SYNR_STAKE) { conf.synrAmount = uint96(uint256(conf.synrAmount).sub(tokenAmount)); } else { conf.passAmount--; } } } function setBridge(address bridge_, bool active) external override onlyOwner { require(bridge_.isContract(), "SeedPool: bridge_ not a contract"); if (active) { bridges[bridge_] = true; emit BridgeSet(bridge_); } else { delete bridges[bridge_]; emit BridgeRemoved(bridge_); } } function initPool(uint16 minimumLockupTime_, uint16 earlyUnstakePenalty_) external override onlyOwner { require(sSynr.isOperatorInRole(address(this), 0x0004_0000), "MainPool: contract cannot receive sSYNR"); require(conf.maximumLockupTime == 0, "MainPool: already initiated"); conf = Conf({ status: 1, minimumLockupTime: minimumLockupTime_, maximumLockupTime: 365, earlyUnstakePenalty: earlyUnstakePenalty_, passAmount: 0, synrAmount: 0, reserved1: 0, reserved2: 0, reserved3: 0 }); emit PoolInitiated(minimumLockupTime_, earlyUnstakePenalty_); } function updateConf(uint16 minimumLockupTime_, uint16 earlyUnstakePenalty_) external override onlyOwner { if (minimumLockupTime_ != 0) { conf.minimumLockupTime = minimumLockupTime_; } if (earlyUnstakePenalty_ != 0) { conf.earlyUnstakePenalty = earlyUnstakePenalty_; } emit PoolConfUpdated(minimumLockupTime_, earlyUnstakePenalty_); } function pausePool(bool paused) external onlyOwner { conf.status = paused ? 2 : 1; emit PoolPaused(paused); } /** * @notice Converts the input payload to the transfer payload * @param deposit The deposit * @return the payload, an encoded uint256 */ function _fromDepositToTransferPayload(Deposit memory deposit) internal pure returns (uint256) { return uint256(deposit.tokenType) .add(uint256(deposit.lockedFrom).mul(100)) .add(uint256(deposit.lockedUntil).mul(1e12)) .add(uint256(deposit.mainIndex).mul(1e22)) .add(uint256(deposit.tokenAmountOrID).mul(1e27)); } /** * @notice updates the user with the staked amount or the pass amount and creates new deposit for the user * @param user address of user being updated * @param tokenType identifies the type of transaction being made, 0=SSYNR, 1=SYNR, 2 or 3 = SYNR PASS. * @param lockedFrom timestamp when locked * @param lockedUntil timestamp when can unstake without penalty * @param tokenAmountOrID ammount of tokens being staked, in the case where a SYNR Pass is being staked, it identified its ID * @param otherChain chainID of recieving chain * @param mainIndex index of deposit being updated * @return the new deposit */ function _updateUserAndAddDeposit( address user, uint256 tokenType, uint256 lockedFrom, uint256 lockedUntil, uint256 tokenAmountOrID, uint16 otherChain, uint256 mainIndex ) internal returns (Deposit memory) { if (tokenType == SYNR_STAKE) { users[user].synrAmount += uint96(tokenAmountOrID); } else if (tokenType == SYNR_PASS_STAKE_FOR_BOOST || tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { users[user].passAmount++; } _updateTvl(tokenType, tokenAmountOrID, true); Deposit memory deposit = Deposit({ tokenType: uint8(tokenType), lockedFrom: uint32(lockedFrom), lockedUntil: uint32(lockedUntil), tokenAmountOrID: uint96(tokenAmountOrID), unlockedAt: 0, otherChain: otherChain, mainIndex: uint16(mainIndex), extra: 0 }); users[user].deposits.push(deposit); return deposit; } /** * @notice Searches for deposit from the user and its index * @param user address of user who made deposit being searched * @param index index of the deposit being searched * @return the deposit */ function getDepositByIndex(address user, uint256 index) external view override returns (Deposit memory) { if (users[user].deposits.length <= index || users[user].deposits[index].lockedFrom == 0) { Deposit memory deposit; return deposit; } else { return users[user].deposits[index]; } } /** * @param user address of user * @return the ammount of deposits a user has made */ function getDepositsLength(address user) public view override returns (uint256) { return users[user].deposits.length; } /** * @notice makes the deposit * @param tokenType identifies the type of transaction being made, 0=SSYNR, 1=SYNR, 2 or 3 = SYNR PASS. * @param lockupTime time the staking will take * @param tokenAmountOrID ammount of tokens being staked, in the case where a SYNR Pass is being staked, it identified its ID * @param otherChain chainID of recieving chain * @return the TransferPayload calculated from the deposit */ function _makeDeposit( address user, uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID, uint16 otherChain ) internal returns (uint256) { require(tokenType < BLUEPRINT_STAKE_FOR_BOOST, "MainPool: invalid tokenType"); validateInput(tokenType, lockupTime, tokenAmountOrID); if (tokenType == S_SYNR_SWAP || tokenType == SYNR_STAKE) { require(tokenAmountOrID >= 1e18, "MainPool: must stake at least one unity"); } if (tokenType == SYNR_STAKE || tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { require( lockupTime > conf.minimumLockupTime - 1 && lockupTime < conf.maximumLockupTime + 1, "MainPool: invalid lockupTime type" ); } // Contract must be approved as spender. // It will throw if the balance is insufficient if (tokenType == S_SYNR_SWAP) { // MainPool must be whitelisted to receive sSYNR sSynr.transferFrom(user, address(this), tokenAmountOrID); } else if (tokenType == SYNR_STAKE) { // MainPool must be approved to spend the SYNR synr.safeTransferFrom(user, address(this), tokenAmountOrID, ""); } else { // SYNR Pass // MainPool must be approved to make the transfer pass.safeTransferFrom(user, address(this), tokenAmountOrID); } return _fromDepositToTransferPayload(_updateUser(user, tokenType, lockupTime, tokenAmountOrID, otherChain)); } /** * @notice updates the user, calls _updateUserAndAddDeposit * @param user address of user being updated * @param tokenType identifies the type of transaction being made, 0=SSYNR, 1=SYNR, 2 or 3 = SYNR PASS. * @param lockupTime time the staking will take * @param tokenAmountOrID ammount of tokens being staked, in the case where a SYNR Pass is being staked, it identified its ID * @param otherChain chainID of recieving chain * @return the deposit */ function _updateUser( address user, uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID, uint16 otherChain ) internal returns (Deposit memory) { uint256 lockedUntil = tokenType == SYNR_STAKE || tokenType == SYNR_PASS_STAKE_FOR_SEEDS ? uint32(block.timestamp.add(lockupTime * 1 days)) : 0; Deposit memory deposit = _updateUserAndAddDeposit( user, tokenType, uint32(block.timestamp), lockedUntil, tokenAmountOrID, otherChain, getDepositsLength(user) ); return deposit; } /** * @notice unstakes a deposit, calculates penalty for early unstake * @param user address of user * @param tokenType identifies the type of transaction being made, 0=SSYNR, 1=SYNR, 2 or 3 = SYNR PASS. * @param lockedFrom timestamp when locked * @param lockedUntil timestamp when can unstake without penalty * @param mainIndex index of deposit * @param tokenAmountOrID ammount of tokens being staked, in the case where a SYNR Pass is being staked, it identified its ID */ function _unstake( address user, uint256 tokenType, uint256 lockedFrom, uint256 lockedUntil, uint256 mainIndex, uint256 tokenAmountOrID ) internal { Deposit storage deposit = users[user].deposits[mainIndex]; require( uint256(deposit.mainIndex) == mainIndex && uint256(deposit.tokenType) == tokenType && uint256(deposit.lockedFrom) == lockedFrom && uint256(deposit.lockedUntil) == lockedUntil && uint256(deposit.tokenAmountOrID) == tokenAmountOrID, "MainPool: inconsistent deposit" ); require(deposit.unlockedAt == 0, "MainPool: deposit already unlocked"); require(tokenType > S_SYNR_SWAP, "MainPool: sSYNR can not be unstaked"); if (tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { require(lockedUntil < block.timestamp, "MainPool: SYNR Pass cannot be early unstaked"); } if (tokenType == SYNR_STAKE) { users[user].synrAmount = uint96(uint256(users[user].synrAmount).sub(tokenAmountOrID)); } else { users[user].passAmount = uint16(uint256(users[user].passAmount).sub(1)); } _updateTvl(tokenType, tokenAmountOrID, false); if (tokenType == SYNR_PASS_STAKE_FOR_BOOST || tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { pass.safeTransferFrom(address(this), user, uint256(tokenAmountOrID)); } else { uint256 penalty = calculatePenaltyForEarlyUnstake(block.timestamp, deposit); uint256 amount = uint256(tokenAmountOrID).sub(penalty); synr.safeTransferFrom(address(this), user, amount, ""); if (penalty > 0) { penalties += penalty; } } deposit.unlockedAt = uint32(block.timestamp); emit DepositUnlocked(user, uint16(mainIndex)); } /** * @notice gets Percentage Vested at a certain timestamp * @param when timestamp where percentage will be calculated * @param lockedFrom timestamp when locked * @param lockedUntil timestamp when can unstake without penalty * @return the percentage vested */ function getVestedPercentage( uint256 when, uint256 lockedFrom, uint256 lockedUntil ) public pure override returns (uint256) { if (lockedUntil == 0) { return 10000; } uint256 lockupTime = lockedUntil.sub(lockedFrom); if (lockupTime == 0) { return 10000; } uint256 vestedTime = when.sub(lockedFrom); return vestedTime.mul(10000).div(lockupTime); } /** * @notice calculates penalty when unstaking SYNR before period is up * @param when timestamp where percentage will be calculated * @param deposit deposit from where penalty is to be calculated * @return the penalty, if any */ function calculatePenaltyForEarlyUnstake(uint256 when, Deposit memory deposit) public view override returns (uint256) { if (when > uint256(deposit.lockedUntil)) { return 0; } uint256 vestedPercentage = getVestedPercentage(when, uint256(deposit.lockedFrom), uint256(deposit.lockedUntil)); uint256 vestedAmount = uint256(deposit.tokenAmountOrID).mul(vestedPercentage).div(10000); return uint256(deposit.tokenAmountOrID).sub(vestedAmount).mul(conf.earlyUnstakePenalty).div(10000); } /** * @notice Withdraws SSYNR that has been Swapped to the contract * @param amount amount of ssynr to be withdrawn * @param beneficiary address to which the withdrawl will go to */ function withdrawSSynr(uint256 amount, address beneficiary) external override onlyOwner { uint256 availableAmount = sSynr.balanceOf(address(this)); require(availableAmount > 0 && amount <= availableAmount, "MainPool: sSYNR amount not available"); if (amount == 0) { amount = availableAmount; } // the approve is necessary, because of a bug in the sSYNR contract sSynr.approve(address(this), amount); // beneficiary must be whitelisted to receive sSYNR sSynr.transferFrom(address(this), beneficiary, amount); } /** * @notice Withdraws SYNR that has been collected as tax for unstaking early * @param amount amount of ssynr to be withdrawn * @param beneficiary address to which the withdrawl will go to */ function withdrawPenalties(uint256 amount, address beneficiary) external override onlyOwner { require(penalties > 0 && amount <= penalties, "MainPool: amount not available"); require(beneficiary != address(0), "MainPool: beneficiary cannot be zero address"); if (amount == 0) { amount = penalties; } penalties -= amount; synr.safeTransferFrom(address(this), beneficiary, amount, ""); } /** * @notice stakes the payload if the pool is active * @param user address of user * @param payload an uint256 encoded with the information of the deposit * @param recipientChain chain to where the transfer will go */ function _stake( address user, uint256 payload, uint16 recipientChain ) internal returns (uint256) { require(conf.status == 1, "MainPool: not initiated or paused"); (uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID) = deserializeInput(payload); require(conf.minimumLockupTime > 0, "MainPool: pool not alive"); payload = _makeDeposit(user, tokenType, lockupTime, tokenAmountOrID, recipientChain); emit DepositSaved(user, uint16(getIndexFromPayload(payload))); return payload; } function stake( address user, uint256 payload, uint16 recipientChain ) external virtual onlyBridge returns (uint256) { require(getDepositsLength(user) < 50, "MainPool: maximum number of deposits reached"); return _stake(user, payload, recipientChain); } function unstake( address user, uint256 tokenType, uint256 lockedFrom, uint256 lockedUntil, uint256 mainIndex, uint256 tokenAmountOrID ) external virtual onlyBridge { _unstake(user, tokenType, lockedFrom, lockedUntil, mainIndex, tokenAmountOrID); } function validateInput( uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID ) public pure override returns (bool) { require(tokenType < BLUEPRINT_STAKE_FOR_SEEDS + 1, "PayloadUtils: invalid token type"); if (tokenType == SYNR_PASS_STAKE_FOR_BOOST || tokenType == SYNR_PASS_STAKE_FOR_SEEDS) { require(tokenAmountOrID < 889, "PayloadUtils: Not a Mobland SYNR Pass token ID"); } else if (tokenType == BLUEPRINT_STAKE_FOR_BOOST || tokenType == BLUEPRINT_STAKE_FOR_SEEDS) { require(tokenAmountOrID < 8001, "PayloadUtils: Not a Blueprint token ID"); } else { require(tokenAmountOrID < 1e28, "PayloadUtils: tokenAmountOrID out of range"); } require(lockupTime < 1e3, "PayloadUtils: lockedTime out of range"); return true; } function deserializeInput(uint256 payload) public pure override returns ( uint256 tokenType, uint256 lockupTime, uint256 tokenAmountOrID ) { tokenType = payload.mod(100); lockupTime = payload.div(100).mod(1e3); tokenAmountOrID = payload.div(1e5); } function getIndexFromPayload(uint256 payload) public pure override returns (uint256) { return payload.div(1e22).mod(1e5); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bridge","type":"address"}],"name":"BridgeRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bridge","type":"address"}],"name":"BridgeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint16","name":"mainIndex","type":"uint16"}],"name":"DepositSaved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint16","name":"mainIndex","type":"uint16"}],"name":"DepositUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newImplementation","type":"address"}],"name":"ImplementationUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"minimumLockupTime","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"earlyUnstakePenalty","type":"uint16"}],"name":"PoolConfUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"minimumLockupTime","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"earlyUnstakePenalty","type":"uint16"}],"name":"PoolInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isPaused","type":"bool"}],"name":"PoolPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"BLUEPRINT_STAKE_FOR_BOOST","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BLUEPRINT_STAKE_FOR_SEEDS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SYNR_PASS_STAKE_FOR_BOOST","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SYNR_PASS_STAKE_FOR_SEEDS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SYNR_STAKE","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"S_SYNR_SWAP","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bridges","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"when","type":"uint256"},{"components":[{"internalType":"uint8","name":"tokenType","type":"uint8"},{"internalType":"uint32","name":"lockedFrom","type":"uint32"},{"internalType":"uint32","name":"lockedUntil","type":"uint32"},{"internalType":"uint96","name":"tokenAmountOrID","type":"uint96"},{"internalType":"uint32","name":"unlockedAt","type":"uint32"},{"internalType":"uint16","name":"otherChain","type":"uint16"},{"internalType":"uint16","name":"mainIndex","type":"uint16"},{"internalType":"uint24","name":"extra","type":"uint24"}],"internalType":"struct IMainUser.Deposit","name":"deposit","type":"tuple"}],"name":"calculatePenaltyForEarlyUnstake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"conf","outputs":[{"internalType":"uint8","name":"status","type":"uint8"},{"internalType":"uint16","name":"minimumLockupTime","type":"uint16"},{"internalType":"uint16","name":"maximumLockupTime","type":"uint16"},{"internalType":"uint16","name":"earlyUnstakePenalty","type":"uint16"},{"internalType":"uint16","name":"passAmount","type":"uint16"},{"internalType":"uint96","name":"synrAmount","type":"uint96"},{"internalType":"uint32","name":"reserved1","type":"uint32"},{"internalType":"uint32","name":"reserved2","type":"uint32"},{"internalType":"uint24","name":"reserved3","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"payload","type":"uint256"}],"name":"deserializeInput","outputs":[{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"uint256","name":"lockupTime","type":"uint256"},{"internalType":"uint256","name":"tokenAmountOrID","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getDepositByIndex","outputs":[{"components":[{"internalType":"uint8","name":"tokenType","type":"uint8"},{"internalType":"uint32","name":"lockedFrom","type":"uint32"},{"internalType":"uint32","name":"lockedUntil","type":"uint32"},{"internalType":"uint96","name":"tokenAmountOrID","type":"uint96"},{"internalType":"uint32","name":"unlockedAt","type":"uint32"},{"internalType":"uint16","name":"otherChain","type":"uint16"},{"internalType":"uint16","name":"mainIndex","type":"uint16"},{"internalType":"uint24","name":"extra","type":"uint24"}],"internalType":"struct IMainUser.Deposit","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getDepositsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"payload","type":"uint256"}],"name":"getIndexFromPayload","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"when","type":"uint256"},{"internalType":"uint256","name":"lockedFrom","type":"uint256"},{"internalType":"uint256","name":"lockedUntil","type":"uint256"}],"name":"getVestedPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint16","name":"minimumLockupTime_","type":"uint16"},{"internalType":"uint16","name":"earlyUnstakePenalty_","type":"uint16"}],"name":"initPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"synr_","type":"address"},{"internalType":"address","name":"sSynr_","type":"address"},{"internalType":"address","name":"pass_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC20Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pass","outputs":[{"internalType":"contract IERC721Minimal","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"paused","type":"bool"}],"name":"pausePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"penalties","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sSynr","outputs":[{"internalType":"contract ISyntheticSyndicateERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"bridge_","type":"address"},{"internalType":"bool","name":"active","type":"bool"}],"name":"setBridge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"payload","type":"uint256"},{"internalType":"uint16","name":"recipientChain","type":"uint16"}],"name":"stake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"synr","outputs":[{"internalType":"contract ISyndicateERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"uint256","name":"lockedFrom","type":"uint256"},{"internalType":"uint256","name":"lockedUntil","type":"uint256"},{"internalType":"uint256","name":"mainIndex","type":"uint256"},{"internalType":"uint256","name":"tokenAmountOrID","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"minimumLockupTime_","type":"uint16"},{"internalType":"uint16","name":"earlyUnstakePenalty_","type":"uint16"}],"name":"updateConf","outputs":[],"stateMutability":"nonpayable","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"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"users","outputs":[{"internalType":"uint96","name":"synrAmount","type":"uint96"},{"internalType":"uint16","name":"passAmount","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"uint256","name":"lockupTime","type":"uint256"},{"internalType":"uint256","name":"tokenAmountOrID","type":"uint256"}],"name":"validateInput","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"}],"name":"withdrawPenalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"beneficiary","type":"address"}],"name":"withdrawSSynr","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
48431:17004:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47770:51;;;;;;;;;;;;47820:1;47770:51;;;;;186:4:1;174:17;;;156:36;;144:2;129:18;47770:51:0;;;;;;;;42504:182;;;;;;;;;;-1:-1:-1;42504:182:0;;;;;:::i;:::-;-1:-1:-1;;;42504:182:0;;;;;;;;;;;-1:-1:-1;;;;;;1356:33:1;;;1338:52;;1326:2;1311:18;42504:182:0;1194:202:1;48710:16:0;;;;;;;;;;-1:-1:-1;48710:16:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;48710:16:0;;;;;-1:-1:-1;;;48710:16:0;;;;;;-1:-1:-1;;;;;;;;48710:16:0;;;;;-1:-1:-1;;;48710:16:0;;;;;-1:-1:-1;;;48710:16:0;;;;;;;-1:-1:-1;;;48710:16:0;;;;;;;;;;2073:4:1;2061:17;;;2043:36;;2098:6;2140:15;;;2135:2;2120:18;;2113:43;2192:15;;;2172:18;;;2165:43;;;;2244:15;;;2239:2;2224:18;;2217:43;2297:15;;;;2291:3;2276:19;;2269:44;-1:-1:-1;;;;;2350:39:1;2344:3;2329:19;;2322:68;2409:10;2456:15;;;2450:3;2435:19;;2428:44;2509:15;;;;2503:3;2488:19;;2481:44;2574:8;2562:21;2556:3;2541:19;;2534:50;2030:3;2015:19;48710:16:0;1692:898:1;47575:37:0;;;;;;;;;;;;47611:1;47575:37;;65301:131;;;;;;;;;;-1:-1:-1;65301:131:0;;;;;:::i;:::-;;:::i;:::-;;;2926:25:1;;;2914:2;2899:18;65301:131:0;2780:177:1;60190:416:0;;;;;;;;;;-1:-1:-1;60190:416:0;;;;;:::i;:::-;;:::i;51257:375::-;;;;;;;;;;-1:-1:-1;51257:375:0;;;;;:::i;:::-;;:::i;:::-;;26354:200;;;;;;;;;;-1:-1:-1;26354:200:0;;;;;:::i;:::-;;:::i;50614:637::-;;;;;;;;;;-1:-1:-1;50614:637:0;;;;;:::i;:::-;;:::i;48840:24::-;;;;;;;;;;;;;;;;26813:225;;;;;;:::i;:::-;;:::i;42316:182::-;;;;;;;;;;-1:-1:-1;42316:182:0;;;;;:::i;:::-;-1:-1:-1;;;42316:182:0;;;;;;;;26032:133;;;;;;;;;;;;;:::i;48118:80::-;;;;;;;;;;-1:-1:-1;48191:1:0;48118:80;;38276:103;;;;;;;;;;;;;:::i;47826:51::-;;;;;;;;;;;;47876:1;47826:51;;63875:289;;;;;;;;;;-1:-1:-1;63875:289:0;;;;;:::i;:::-;;:::i;54099:324::-;;;;;;;;;;-1:-1:-1;54099:324:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;62364:425::-;;;;;;;;;;-1:-1:-1;62364:425:0;;;;;:::i;:::-;;:::i;64980:315::-;;;;;;;;;;-1:-1:-1;64980:315:0;;;;;:::i;:::-;;:::i;:::-;;;;7886:25:1;;;7942:2;7927:18;;7920:34;;;;7970:18;;;7963:34;7874:2;7859:18;64980:315:0;7684:319:1;37625:87:0;;;;;;;;;;-1:-1:-1;37698:6:0;;-1:-1:-1;;;;;37698:6:0;37625:87;;;-1:-1:-1;;;;;8172:32:1;;;8154:51;;8142:2;8127:18;37625:87:0;8008:203:1;48807:26:0;;;;;;;;;;-1:-1:-1;48807:26:0;;;;-1:-1:-1;;;;;48807:26:0;;;48668:37;;;;;;;;;;-1:-1:-1;48668:37:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;48668:37:0;;;-1:-1:-1;;;48668:37:0;;;;;;;;;;-1:-1:-1;;;;;8635:39:1;;;8617:58;;8723:6;8711:19;;;8706:2;8691:18;;8684:47;8590:18;48668:37:0;8447:290:1;49105:462:0;;;;;;;;;;-1:-1:-1;49105:462:0;;;;;:::i;:::-;;:::i;51638:122::-;;;;;;;;;;-1:-1:-1;51638:122:0;;;;;:::i;:::-;;:::i;48871:39::-;;;;;;;;;;-1:-1:-1;48871:39:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;9615:14:1;;9608:22;9590:41;;9578:2;9563:18;48871:39:0;9450:187:1;48765:37:0;;;;;;;;;;-1:-1:-1;48765:37:0;;;;-1:-1:-1;;;;;48765:37:0;;;61586:559;;;;;;;;;;-1:-1:-1;61586:559:0;;;;;:::i;:::-;;:::i;63585:284::-;;;;;;;;;;-1:-1:-1;63585:284:0;;;;;:::i;:::-;;:::i;47658:51::-;;;;;;;;;;;;47708:1;47658:51;;50281:327;;;;;;;;;;-1:-1:-1;50281:327:0;;;;;:::i;:::-;;:::i;54531:127::-;;;;;;;;;;-1:-1:-1;54531:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;54625:11:0;54602:7;54625:11;;;:5;:11;;;;;:20;;:27;;54531:127;48733:27;;;;;;;;;;-1:-1:-1;48733:27:0;;;;-1:-1:-1;;;;;48733:27:0;;;47714:51;;;;;;;;;;;;47764:1;47714:51;;38534:201;;;;;;;;;;-1:-1:-1;38534:201:0;;;;;:::i;:::-;;:::i;47617:36::-;;;;;;;;;;;;47652:1;47617:36;;60865:514;;;;;;;;;;-1:-1:-1;60865:514:0;;;;;:::i;:::-;;:::i;64170:804::-;;;;;;;;;;-1:-1:-1;64170:804:0;;;;;:::i;:::-;;:::i;65301:131::-;65377:7;65400:26;65422:3;65400:17;:7;65412:4;65400:11;:17::i;:::-;:21;;:26::i;:::-;65393:33;65301:131;-1:-1:-1;;65301:131:0:o;60190:416::-;60324:7;60344:16;60340:51;;-1:-1:-1;60378:5:0;60371:12;;60340:51;60397:18;60418:27;:11;60434:10;60418:15;:27::i;:::-;60397:48;-1:-1:-1;60456:15:0;60452:50;;60489:5;60482:12;;;;;60452:50;60508:18;60529:20;:4;60538:10;60529:8;:20::i;:::-;60508:41;-1:-1:-1;60563:37:0;60589:10;60563:21;60508:41;60578:5;60563:14;:21::i;:::-;:25;;:37::i;:::-;60556:44;;;;60190:416;;;;;;:::o;51257:375::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;;;;;;;;;51372:23:::1;::::0;::::1;::::0;51368:89:::1;;51406:4;:43:::0;;-1:-1:-1;;51406:43:0::1;;;::::0;::::1;;;::::0;;51368:89:::1;51467:25;::::0;::::1;::::0;51463:95:::1;;51503:4;:47:::0;;-1:-1:-1;;51503:47:0::1;-1:-1:-1::0;;;51503:47:0::1;::::0;::::1;;;::::0;;51463:95:::1;51569:57;::::0;;12874:6:1;12907:15;;;12889:34;;12959:15;;12954:2;12939:18;;12932:43;51569:57:0::1;::::0;12837:18:1;51569:57:0::1;;;;;;;;51257:375:::0;;:::o;26354:200::-;24895:4;-1:-1:-1;;;;;24904:6:0;24887:23;;;24879:80;;;;-1:-1:-1;;;24879:80:0;;;;;;;:::i;:::-;25002:6;-1:-1:-1;;;;;24978:30:0;:20;-1:-1:-1;;;;;;;;;;;16670:65:0;-1:-1:-1;;;;;16670:65:0;;16590:153;24978:20;-1:-1:-1;;;;;24978:30:0;;24970:87;;;;-1:-1:-1;;;24970:87:0;;;;;;;:::i;:::-;26438:36:::1;26456:17;26438;:36::i;:::-;26526:12;::::0;;26536:1:::1;26526:12:::0;;;::::1;::::0;::::1;::::0;;;26485:61:::1;::::0;26507:17;;26526:12;26485:21:::1;:61::i;:::-;26354:200:::0;:::o;50614:637::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;50731:5:::1;::::0;:50:::1;::::0;-1:-1:-1;;;50731:50:0;;50762:4:::1;50731:50;::::0;::::1;13999:51:1::0;50769:11:0::1;14066:18:1::0;;;14059:34;-1:-1:-1;;;;;50731:5:0;;::::1;::::0;:22:::1;::::0;13972:18:1;;50731:50:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50723:102;;;::::0;-1:-1:-1;;;50723:102:0;;14556:2:1;50723:102:0::1;::::0;::::1;14538:21:1::0;14595:2;14575:18;;;14568:30;14634:34;14614:18;;;14607:62;-1:-1:-1;;;14685:18:1;;;14678:37;14732:19;;50723:102:0::1;14354:403:1::0;50723:102:0::1;50840:4;:22:::0;;;::::1;;;:27:::0;50832:67:::1;;;::::0;-1:-1:-1;;;50832:67:0;;14964:2:1;50832:67:0::1;::::0;::::1;14946:21:1::0;15003:2;14983:18;;;14976:30;15042:29;15022:18;;;15015:57;15089:18;;50832:67:0::1;14762:351:1::0;50832:67:0::1;50913:265;::::0;;::::1;::::0;::::1;::::0;;50935:1:::1;50913:265:::0;;;::::1;::::0;;::::1;;::::0;;::::1;::::0;;;51010:3:::1;50913:265:::0;;;;;;::::1;::::0;;;;;;-1:-1:-1;50913:265:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50906:4:::1;:272:::0;;;-1:-1:-1;;50906:272:0;;;;;::::1;::::0;;;;;;;-1:-1:-1;;50906:272:0;-1:-1:-1;;;50906:272:0;::::1;::::0;;;;;;;;;;51190:55;;12889:34:1;;;12939:18;;12932:43;;;;51190:55:0::1;::::0;12837:18:1;51190:55:0::1;12694:287:1::0;26813:225:0;24895:4;-1:-1:-1;;;;;24904:6:0;24887:23;;;24879:80;;;;-1:-1:-1;;;24879:80:0;;;;;;;:::i;:::-;25002:6;-1:-1:-1;;;;;24978:30:0;:20;-1:-1:-1;;;;;;;;;;;16670:65:0;-1:-1:-1;;;;;16670:65:0;;16590:153;24978:20;-1:-1:-1;;;;;24978:30:0;;24970:87;;;;-1:-1:-1;;;24970:87:0;;;;;;;:::i;:::-;26931:36:::1;26949:17;26931;:36::i;:::-;26978:52;27000:17;27019:4;27025;26978:21;:52::i;:::-;26813:225:::0;;:::o;26032:133::-;26110:7;25340:4;-1:-1:-1;;;;;25349:6:0;25332:23;;25324:92;;;;-1:-1:-1;;;25324:92:0;;15320:2:1;25324:92:0;;;15302:21:1;15359:2;15339:18;;;15332:30;15398:34;15378:18;;;15371:62;15469:26;15449:18;;;15442:54;15513:19;;25324:92:0;15118:420:1;25324:92:0;-1:-1:-1;;;;;;;;;;;;26032:133:0;:::o;38276:103::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;38341:30:::1;38368:1;38341:18;:30::i;:::-;38276:103::o:0;63875:289::-;35895:10;48954:21;;;;:7;:21;;;;;;;;48946:53;;;;-1:-1:-1;;;48946:53:0;;15745:2:1;48946:53:0;;;15727:21:1;15784:2;15764:18;;;15757:30;-1:-1:-1;;;15803:18:1;;;15796:49;15862:18;;48946:53:0;15543:343:1;48946:53:0;64080:78:::1;64089:4;64095:9;64106:10;64118:11;64131:9;64142:15;64080:8;:78::i;:::-;63875:289:::0;;;;;;:::o;54099:324::-;54187:14;;:::i;:::-;-1:-1:-1;;;;;54214:11:0;;;;;;:5;:11;;;;;:20;;:27;:36;-1:-1:-1;54214:36:0;;:83;;-1:-1:-1;;;;;;54254:11:0;;;;;;:5;:11;;;;;:20;;:27;;54275:5;;54254:27;;;;;;:::i;:::-;;;;;;;;;;:38;;;;;;:43;54214:83;54210:208;;;54308:22;;:::i;:::-;54346:7;-1:-1:-1;54339:14:0;;54210:208;-1:-1:-1;;;;;54383:11:0;;;;;;:5;:11;;;;;:20;;:27;;54404:5;;54383:27;;;;;;:::i;:::-;;;;;;;;;;54376:34;;;;;;;;;54383:27;;;;54376:34;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;54376:34:0;;;;;;;;-1:-1:-1;;;54376:34:0;;-1:-1:-1;;;;;54376:34:0;;;;;-1:-1:-1;;;54376:34:0;;;;;;;;;-1:-1:-1;;;54376:34:0;;;;;;;;;;-1:-1:-1;;;54376:34:0;;;;;;;-1:-1:-1;;;54376:34:0;;;;;;;;;54099:324;-1:-1:-1;;;54099:324:0:o;62364:425::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;62483:1:::1;62471:9;;:13;:36;;;;;62498:9;;62488:6;:19;;62471:36;62463:79;;;::::0;-1:-1:-1;;;62463:79:0;;16225:2:1;62463:79:0::1;::::0;::::1;16207:21:1::0;16264:2;16244:18;;;16237:30;16303:32;16283:18;;;16276:60;16353:18;;62463:79:0::1;16023:354:1::0;62463:79:0::1;-1:-1:-1::0;;;;;62557:25:0;::::1;62549:82;;;::::0;-1:-1:-1;;;62549:82:0;;16584:2:1;62549:82:0::1;::::0;::::1;16566:21:1::0;16623:2;16603:18;;;16596:30;16662:34;16642:18;;;16635:62;-1:-1:-1;;;16713:18:1;;;16706:42;16765:19;;62549:82:0::1;16382:408:1::0;62549:82:0::1;62642:11:::0;62638:52:::1;;62673:9;;62664:18;;62638:52;62709:6;62696:9;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;62722:4:0::1;::::0;:61:::1;::::0;-1:-1:-1;;;62722:61:0;;-1:-1:-1;;;;;62722:4:0;;::::1;::::0;:21:::1;::::0;:61:::1;::::0;62752:4:::1;::::0;62759:11;;62772:6;;62722:61:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;64980:315:::0;65081:17;;;65187:16;:7;65199:3;65187:11;:16::i;:::-;65175:28;-1:-1:-1;65223:25:0;65244:3;65223:16;:7;65235:3;65223:11;:16::i;:25::-;65210:38;-1:-1:-1;65273:16:0;:7;65285:3;65273:11;:16::i;:::-;64980:315;;;;-1:-1:-1;;64980:315:0:o;49105:462::-;10104:13;;;;;;;:48;;10140:12;;;;10139:13;10104:48;;;10907:4;1663:19;:23;10120:16;10096:107;;;;-1:-1:-1;;;10096:107:0;;17819:2:1;10096:107:0;;;17801:21:1;17858:2;17838:18;;;17831:30;17897:34;17877:18;;;17870:62;-1:-1:-1;;;17948:18:1;;;17941:44;18002:19;;10096:107:0;17617:410:1;10096:107:0;10239:13;;;;;;;10238:14;10263:101;;;;10298:13;:20;;-1:-1:-1;;10333:19:0;;;;;10263:101;49251:16:::1;:14;:16::i;:::-;-1:-1:-1::0;;;;;49282:16:0;::::1;1663:19:::0;49274:51:::1;;;::::0;-1:-1:-1;;;49274:51:0;;18234:2:1;49274:51:0::1;::::0;::::1;18216:21:1::0;18273:2;18253:18;;;18246:30;-1:-1:-1;;;18292:18:1;;;18285:50;18352:18;;49274:51:0::1;18032:344:1::0;49274:51:0::1;-1:-1:-1::0;;;;;49340:17:0;::::1;1663:19:::0;49332:53:::1;;;::::0;-1:-1:-1;;;49332:53:0;;18583:2:1;49332:53:0::1;::::0;::::1;18565:21:1::0;18622:2;18602:18;;;18595:30;-1:-1:-1;;;18641:18:1;;;18634:51;18702:18;;49332:53:0::1;18381:345:1::0;49332:53:0::1;-1:-1:-1::0;;;;;49400:16:0;::::1;1663:19:::0;49392:51:::1;;;::::0;-1:-1:-1;;;49392:51:0;;18933:2:1;49392:51:0::1;::::0;::::1;18915:21:1::0;18972:2;18952:18;;;18945:30;-1:-1:-1;;;18991:18:1;;;18984:50;19051:18;;49392:51:0::1;18731:344:1::0;49392:51:0::1;49450:4;:29:::0;;-1:-1:-1;;;;;49450:29:0;;::::1;-1:-1:-1::0;;;;;;49450:29:0;;::::1;;::::0;;;49486:5:::1;:40:::0;;;;::::1;::::0;;::::1;;::::0;;49533:4:::1;:28:::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;10390:68;;;;10425:13;:21;;-1:-1:-1;;10425:21:0;;;10390:68;9811:654;49105:462;;;:::o;51638:122::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;51710:6:::1;:14;;51723:1;51710:14;;;51719:1;51710:14;51696:4;:28:::0;;-1:-1:-1;;51696:28:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;51736:18:::1;::::0;9615:14:1;;9608:22;9590:41;;51736:18:0::1;::::0;9578:2:1;9563:18;51736::0::1;;;;;;;;51638:122:::0;:::o;61586:559::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;61707:5:::1;::::0;:30:::1;::::0;-1:-1:-1;;;61707:30:0;;61731:4:::1;61707:30;::::0;::::1;8154:51:1::0;61681:23:0::1;::::0;-1:-1:-1;;;;;61707:5:0::1;::::0;:15:::1;::::0;8127:18:1;;61707:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61681:56;;61770:1;61752:15;:19;:48;;;;;61785:15;61775:6;:25;;61752:48;61744:97;;;::::0;-1:-1:-1;;;61744:97:0;;19471:2:1;61744:97:0::1;::::0;::::1;19453:21:1::0;19510:2;19490:18;;;19483:30;19549:34;19529:18;;;19522:62;-1:-1:-1;;;19600:18:1;;;19593:34;19644:19;;61744:97:0::1;19269:400:1::0;61744:97:0::1;61852:11:::0;61848:58:::1;;61883:15;61874:24;;61848:58;61985:5;::::0;:36:::1;::::0;-1:-1:-1;;;61985:36:0;;62007:4:::1;61985:36;::::0;::::1;13999:51:1::0;14066:18;;;14059:34;;;-1:-1:-1;;;;;61985:5:0;;::::1;::::0;:13:::1;::::0;13972:18:1;;61985:36:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;62085:5:0::1;::::0;:54:::1;::::0;-1:-1:-1;;;62085:54:0;;-1:-1:-1;;;;;62085:5:0;;::::1;::::0;-1:-1:-1;62085:18:0::1;::::0;-1:-1:-1;62085:54:0::1;::::0;62112:4:::1;::::0;62119:11;;62132:6;;62085:54:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61674:471;61586:559:::0;;:::o;63585:284::-;35895:10;63711:7;48954:21;;;:7;:21;;;;;;;;48946:53;;;;-1:-1:-1;;;48946:53:0;;15745:2:1;48946:53:0;;;15727:21:1;15784:2;15764:18;;;15757:30;-1:-1:-1;;;15803:18:1;;;15796:49;15862:18;;48946:53:0;15543:343:1;48946:53:0;63761:2:::1;63735:23;63753:4;-1:-1:-1::0;;;;;54625:11:0;54602:7;54625:11;;;:5;:11;;;;;:20;;:27;;54531:127;63735:23:::1;:28;63727:85;;;::::0;-1:-1:-1;;;63727:85:0;;20535:2:1;63727:85:0::1;::::0;::::1;20517:21:1::0;20574:2;20554:18;;;20547:30;20613:34;20593:18;;;20586:62;-1:-1:-1;;;20664:18:1;;;20657:42;20716:19;;63727:85:0::1;20333:408:1::0;63727:85:0::1;63826:37;63833:4;63839:7;63848:14;63826:6;:37::i;:::-;63819:44:::0;63585:284;-1:-1:-1;;;;63585:284:0:o;50281:327::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50373:18:0;::::1;1663:19:::0;50365:65:::1;;;::::0;-1:-1:-1;;;50365:65:0;;20948:2:1;50365:65:0::1;::::0;::::1;20930:21:1::0;;;20967:18;;;20960:30;21026:34;21006:18;;;20999:62;21078:18;;50365:65:0::1;20746:356:1::0;50365:65:0::1;50441:6;50437:166;;;-1:-1:-1::0;;;;;50458:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;;:23;;-1:-1:-1;;50458:23:0::1;50477:4;50458:23;::::0;;50495:18;;8154:51:1;;;50495:18:0::1;::::0;8127::1;50495::0::1;8008:203:1::0;50437:166:0::1;-1:-1:-1::0;;;;;50543:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;;50536:23;;-1:-1:-1;;50536:23:0::1;::::0;;50573:22;;8154:51:1;;;50573:22:0::1;::::0;8127:18:1;50573:22:0::1;8008:203:1::0;38534:201:0;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;38623:22:0;::::1;38615:73;;;::::0;-1:-1:-1;;;38615:73:0;;21309:2:1;38615:73:0::1;::::0;::::1;21291:21:1::0;21348:2;21328:18;;;21321:30;21387:34;21367:18;;;21360:62;-1:-1:-1;;;21438:18:1;;;21431:36;21484:19;;38615:73:0::1;21107:402:1::0;38615:73:0::1;38699:28;38718:8;38699:18;:28::i;60865:514::-:0;60974:7;61009;:19;;;61001:28;;60994:4;:35;60990:66;;;-1:-1:-1;61047:1:0;61040:8;;60990:66;61062:24;61089:84;61109:4;61123:7;:18;;;61115:27;;61152:7;:19;;;61144:28;;61089:19;:84::i;:::-;61062:111;;61180:20;61203:65;61262:5;61203:54;61240:16;61211:7;:23;;;-1:-1:-1;;;;;61203:32:0;:36;;:54;;;;:::i;:65::-;61337:4;:24;61290:23;;;;61180:88;;-1:-1:-1;61282:91:0;;61367:5;;61282:80;;-1:-1:-1;;;61337:24:0;;;;;;61282:50;;-1:-1:-1;;;;;61282:32:0;61180:88;61282:36;:50::i;:::-;:54;;:80::i;:91::-;61275:98;60865:514;-1:-1:-1;;;;;60865:514:0:o;64170:804::-;64307:4;64340:29;47876:1;64368;64340:29;:::i;:::-;64328:41;;:9;:41;64320:86;;;;-1:-1:-1;;;64320:86:0;;21925:2:1;64320:86:0;;;21907:21:1;;;21944:18;;;21937:30;22003:34;21983:18;;;21976:62;22055:18;;64320:86:0;21723:356:1;64320:86:0;47708:1;64417:38;;;:80;;-1:-1:-1;47764:1:0;64459:38;;64417:80;64413:465;;;64534:3;64516:15;:21;64508:80;;;;-1:-1:-1;;;64508:80:0;;22286:2:1;64508:80:0;;;22268:21:1;22325:2;22305:18;;;22298:30;22364:34;22344:18;;;22337:62;-1:-1:-1;;;22415:18:1;;;22408:44;22469:19;;64508:80:0;22084:410:1;64508:80:0;64413:465;;;47820:1;64606:38;;;:80;;-1:-1:-1;47876:1:0;64648:38;;64606:80;64602:276;;;64723:4;64705:15;:22;64697:73;;;;-1:-1:-1;;;64697:73:0;;22701:2:1;64697:73:0;;;22683:21:1;22740:2;22720:18;;;22713:30;22779:34;22759:18;;;22752:62;-1:-1:-1;;;22830:18:1;;;22823:36;22876:19;;64697:73:0;22499:402:1;64602:276:0;64819:4;64801:15;:22;64793:77;;;;-1:-1:-1;;;64793:77:0;;23108:2:1;64793:77:0;;;23090:21:1;23147:2;23127:18;;;23120:30;23186:34;23166:18;;;23159:62;-1:-1:-1;;;23237:18:1;;;23230:40;23287:19;;64793:77:0;22906:406:1;64793:77:0;64905:3;64892:10;:16;64884:66;;;;-1:-1:-1;;;64884:66:0;;23519:2:1;64884:66:0;;;23501:21:1;23558:2;23538:18;;;23531:30;23597:34;23577:18;;;23570:62;-1:-1:-1;;;23648:18:1;;;23641:35;23693:19;;64884:66:0;23317:401:1;64884:66:0;-1:-1:-1;64964:4:0;64170:804;;;;;:::o;1368:326::-;-1:-1:-1;;;;;1663:19:0;;:23;;;1368:326::o;31890:98::-;31948:7;31975:5;31979:1;31975;:5;:::i;32455:98::-;32513:7;32540:5;32544:1;32540;:5;:::i;31134:98::-;31192:7;31219:5;31223:1;31219;:5;:::i;31491:98::-;31549:7;31576:5;31580:1;31576;:5;:::i;49573:149::-;37698:6;;-1:-1:-1;;;;;37698:6:0;35895:10;37845:23;37837:68;;;;-1:-1:-1;;;37837:68:0;;;;;;;:::i;:::-;49675:41:::1;::::0;-1:-1:-1;;;;;8172:32:1;;8154:51;;49675:41:0::1;::::0;8142:2:1;8127:18;49675:41:0::1;8008:203:1::0;18008:992:0;15961:66;18462:59;;;18458:535;;;18538:37;18557:17;18538:18;:37::i;:::-;18008:992;;;:::o;18458:535::-;18641:17;-1:-1:-1;;;;;18612:61:0;;:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18612:63:0;;;;;;;;-1:-1:-1;;18612:63:0;;;;;;;;;;;;:::i;:::-;;;18608:306;;18842:56;;-1:-1:-1;;;18842:56:0;;24661:2:1;18842:56:0;;;24643:21:1;24700:2;24680:18;;;24673:30;24739:34;24719:18;;;24712:62;-1:-1:-1;;;24790:18:1;;;24783:44;24844:19;;18842:56:0;24459:410:1;18608:306:0;-1:-1:-1;;;;;;;;;;;18726:28:0;;18718:82;;;;-1:-1:-1;;;18718:82:0;;25076:2:1;18718:82:0;;;25058:21:1;25115:2;25095:18;;;25088:30;25154:34;25134:18;;;25127:62;-1:-1:-1;;;25205:18:1;;;25198:39;25254:19;;18718:82:0;24874:405:1;18718:82:0;18676:140;18928:53;18946:17;18965:4;18971:9;18928:17;:53::i;38895:191::-;38988:6;;;-1:-1:-1;;;;;39005:17:0;;;-1:-1:-1;;;;;;39005:17:0;;;;;;;39038:40;;38988:6;;;39005:17;38988:6;;39038:40;;38969:16;;39038:40;38958:128;38895:191;:::o;58149:1747::-;-1:-1:-1;;;;;58362:11:0;;58336:23;58362:11;;;:5;:11;;;;;:20;;:31;;58383:9;;58362:31;;;;;;:::i;:::-;;;;;;;;;;58424:17;;58362:31;;-1:-1:-1;;;;58424:17:0;;;;58416:39;;:91;;;;-1:-1:-1;58476:17:0;;;;58468:39;;58416:91;:145;;;;-1:-1:-1;58528:18:0;;;;;;;58520:41;;58416:145;:201;;;;-1:-1:-1;58582:19:0;;-1:-1:-1;;;58582:19:0;;;;58574:43;;58416:201;:265;;;;-1:-1:-1;58638:23:0;;-1:-1:-1;;;58638:23:0;;-1:-1:-1;;;;;58638:23:0;58630:51;;58416:265;58400:329;;;;-1:-1:-1;;;58400:329:0;;25486:2:1;58400:329:0;;;25468:21:1;25525:2;25505:18;;;25498:30;25564:32;25544:18;;;25537:60;25614:18;;58400:329:0;25284:354:1;58400:329:0;58744:18;;-1:-1:-1;;;58744:18:0;;;;:23;58736:70;;;;-1:-1:-1;;;58736:70:0;;25845:2:1;58736:70:0;;;25827:21:1;25884:2;25864:18;;;25857:30;25923:34;25903:18;;;25896:62;-1:-1:-1;;;25974:18:1;;;25967:32;26016:19;;58736:70:0;25643:398:1;58736:70:0;47611:1;58821:23;;58813:71;;;;-1:-1:-1;;;58813:71:0;;26248:2:1;58813:71:0;;;26230:21:1;26287:2;26267:18;;;26260:30;26326:34;26306:18;;;26299:62;-1:-1:-1;;;26377:18:1;;;26370:33;26420:19;;58813:71:0;26046:399:1;58813:71:0;47764:1;58895:38;;58891:147;;;58966:15;58952:11;:29;58944:86;;;;-1:-1:-1;;;58944:86:0;;26652:2:1;58944:86:0;;;26634:21:1;26691:2;26671:18;;;26664:30;26730:34;26710:18;;;26703:62;-1:-1:-1;;;26781:18:1;;;26774:42;26833:19;;58944:86:0;26450:408:1;58944:86:0;47652:1;59048:23;;59044:225;;;-1:-1:-1;;;;;59122:11:0;;;;;;:5;:11;;;;;:22;59114:52;;-1:-1:-1;;;;;59122:22:0;59150:15;59114:35;:52::i;:::-;-1:-1:-1;;;;;59082:11:0;;;;;;:5;:11;;;;;:85;;-1:-1:-1;;59082:85:0;-1:-1:-1;;;;;59082:85:0;;;;;;;;;;59044:225;;;-1:-1:-1;;;;;59230:11:0;;;;;;:5;:11;;;;;:22;59222:38;;-1:-1:-1;;;59230:22:0;;;;59258:1;59222:35;:38::i;:::-;-1:-1:-1;;;;;59190:11:0;;;;;;:5;:11;;;;;:71;;;;;;;-1:-1:-1;;;59190:71:0;-1:-1:-1;;;;59190:71:0;;;;;;;;;59044:225;59275:45;59286:9;59297:15;59314:5;59275:10;:45::i;:::-;47708:1;59331:38;;;:80;;-1:-1:-1;47764:1:0;59373:38;;59331:80;59327:461;;;59422:4;;:68;;-1:-1:-1;;;59422:68:0;;-1:-1:-1;;;;;59422:4:0;;;;:21;;:68;;59452:4;;59459;;59473:15;;59422:68;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59327:461;;;59531:57;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;59531:57:0;;;;;;;;;;;-1:-1:-1;;;;;;;;59531:57:0;;;;;;;-1:-1:-1;;;59531:57:0;;;;;;;;-1:-1:-1;;;59531:57:0;;;;;;;;-1:-1:-1;;;59531:57:0;;;;;;;;-1:-1:-1;;;59531:57:0;;;;;;;;;;;59513:15;;59531:57;;59563:15;;59531:31;:57::i;:::-;59513:75;-1:-1:-1;59597:14:0;59614:37;59622:15;59513:75;59614:28;:37::i;:::-;59660:4;;:54;;-1:-1:-1;;;59660:54:0;;59597;;-1:-1:-1;;;;;;59660:4:0;;:21;;:54;;59690:4;;59697;;59597:54;;59660;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59737:1;59727:7;:11;59723:58;;;59764:7;59751:9;;:20;;;;;;;:::i;:::-;;;;-1:-1:-1;;59723:58:0;59504:284;;59327:461;59794:44;;-1:-1:-1;;;;59794:44:0;-1:-1:-1;;;59822:15:0;59794:44;;;;;;59850:40;;;;;;-1:-1:-1;;;;;59850:40:0;;;;;-1:-1:-1;;59850:40:0;58329:1567;58149:1747;;;;;;:::o;37326:97::-;10707:13;;;;;;;10699:69;;;;-1:-1:-1;;;10699:69:0;;;;;;;:::i;:::-;37389:26:::1;:24;:26::i;63038:541::-:0;63170:4;:11;63146:7;;63170:11;;;:16;63162:62;;;;-1:-1:-1;;;63162:62:0;;27610:2:1;63162:62:0;;;27592:21:1;27649:2;27629:18;;;27622:30;27688:34;27668:18;;;27661:62;-1:-1:-1;;;27739:18:1;;;27732:31;27780:19;;63162:62:0;27408:397:1;63162:62:0;63232:17;63251:18;63271:23;63298:25;63315:7;63298:16;:25::i;:::-;63338:4;:22;63231:92;;-1:-1:-1;63231:92:0;;-1:-1:-1;63231:92:0;-1:-1:-1;63338:22:0;;;;;63330:63;;;;-1:-1:-1;;;63330:63:0;;28012:2:1;63330:63:0;;;27994:21:1;28051:2;28031:18;;;28024:30;28090:26;28070:18;;;28063:54;28134:18;;63330:63:0;27810:348:1;63330:63:0;63410:74;63423:4;63429:9;63440:10;63452:15;63469:14;63410:12;:74::i;:::-;63400:84;;63522:28;63542:7;63522:19;:28::i;:::-;63496:56;;63509:4;-1:-1:-1;;;;;63496:56:0;;;;;;;;;;;-1:-1:-1;63566:7:0;;63038:541;-1:-1:-1;;;;;63038:541:0:o;16839:284::-;-1:-1:-1;;;;;1663:19:0;;;16913:106;;;;-1:-1:-1;;;16913:106:0;;28365:2:1;16913:106:0;;;28347:21:1;28404:2;28384:18;;;28377:30;28443:34;28423:18;;;28416:62;-1:-1:-1;;;28494:18:1;;;28487:43;28547:19;;16913:106:0;28163:409:1;16913:106:0;-1:-1:-1;;;;;;;;;;;17030:85:0;;-1:-1:-1;;;;;;17030:85:0;-1:-1:-1;;;;;17030:85:0;;;;;;;;;;16839:284::o;17532:297::-;17675:29;17686:17;17675:10;:29::i;:::-;17733:1;17719:4;:11;:15;:28;;;;17738:9;17719:28;17715:107;;;17764:46;17786:17;17805:4;17764:21;:46::i;49728:547::-;49843:8;49839:431;;;47652:1;49866:23;;49862:218;;;49902:4;:38;;49928:11;;49902:4;:15;;:38;;49928:11;;-1:-1:-1;;;49902:38:0;;-1:-1:-1;;;;;49902:38:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;49902:38:0;;;;;-1:-1:-1;;;;;49902:38:0;;;;;;18008:992;;;:::o;49862:218::-;47708:1;49960:38;;;:80;;-1:-1:-1;47764:1:0;50002:38;;49960:80;49956:124;;;50053:4;:17;;-1:-1:-1;;;50053:17:0;;;;;:15;:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;18008:992;;;:::o;49839:431::-;47652:1;50106:23;;50102:161;;;50175:4;:15;50167:41;;-1:-1:-1;;;50175:15:0;;-1:-1:-1;;;;;50175:15:0;50196:11;50167:28;:41::i;:::-;50142:4;:67;;-1:-1:-1;;;;;50142:67:0;;;;-1:-1:-1;;;50142:67:0;-1:-1:-1;;50142:67:0;;;;;;;;;18008:992;;;:::o;50102:161::-;50236:4;:17;;-1:-1:-1;;;50236:17:0;;;;;:15;:17;;;:::i;37431:113::-;10707:13;;;;;;;10699:69;;;;-1:-1:-1;;;10699:69:0;;;;;;;:::i;:::-;37504:32:::1;35895:10:::0;37504:18:::1;:32::i;55110:1436::-:0;55277:7;47820:1;55301:37;;55293:77;;;;-1:-1:-1;;;55293:77:0;;29416:2:1;55293:77:0;;;29398:21:1;29455:2;29435:18;;;29428:30;29494:29;29474:18;;;29467:57;29541:18;;55293:77:0;29214:351:1;55293:77:0;55377:53;55391:9;55402:10;55414:15;55377:13;:53::i;:::-;-1:-1:-1;47611:1:0;55441:24;;;:51;;-1:-1:-1;47652:1:0;55469:23;;55441:51;55437:149;;;55530:4;55511:15;:23;;55503:75;;;;-1:-1:-1;;;55503:75:0;;29772:2:1;55503:75:0;;;29754:21:1;29811:2;29791:18;;;29784:30;29850:34;29830:18;;;29823:62;-1:-1:-1;;;29901:18:1;;;29894:37;29948:19;;55503:75:0;29570:403:1;55503:75:0;47652:1;55596:23;;;:65;;-1:-1:-1;47764:1:0;55623:38;;55596:65;55592:243;;;55703:4;:22;:26;;55728:1;;55703:22;;;;;:26;:::i;:::-;55690:39;;:10;:39;:82;;;;-1:-1:-1;55746:4:0;:22;:26;;:22;;;;;55771:1;55746:26;:::i;:::-;55733:39;;:10;:39;55690:82;55672:155;;;;-1:-1:-1;;;55672:155:0;;30631:2:1;55672:155:0;;;30613:21:1;30670:2;30650:18;;;30643:30;30709:34;30689:18;;;30682:62;-1:-1:-1;;;30760:18:1;;;30753:31;30801:19;;55672:155:0;30429:397:1;55672:155:0;47611:1;55944:24;;55940:487;;;56035:5;;:56;;-1:-1:-1;;;56035:56:0;;-1:-1:-1;;;;;56035:5:0;;;;:18;;:56;;56054:4;;56068;;56075:15;;56035:56;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55940:487;;;47652:1;56109:23;;56105:322;;;56197:4;;:63;;-1:-1:-1;;;56197:63:0;;-1:-1:-1;;;;;56197:4:0;;;;:21;;:63;;56219:4;;56233;;56240:15;;56197:63;;;:::i;56105:322::-;56360:4;;:59;;-1:-1:-1;;;56360:59:0;;-1:-1:-1;;;;;56360:4:0;;;;:21;;:59;;56382:4;;56396;;56403:15;;56360:59;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56105:322;56440:100;56470:69;56482:4;56488:9;56499:10;56511:15;56528:10;56470:11;:69::i;:::-;56440:29;:100::i;:::-;56433:107;55110:1436;-1:-1:-1;;;;;;55110:1436:0:o;17236:155::-;17303:37;17322:17;17303:18;:37::i;:::-;17356:27;;-1:-1:-1;;;;;17356:27:0;;;;;;;;17236:155;:::o;22269:461::-;22352:12;-1:-1:-1;;;;;1663:19:0;;;22377:88;;;;-1:-1:-1;;;22377:88:0;;31033:2:1;22377:88:0;;;31015:21:1;31072:2;31052:18;;;31045:30;31111:34;31091:18;;;31084:62;-1:-1:-1;;;31162:18:1;;;31155:36;31208:19;;22377:88:0;30831:402:1;22377:88:0;22539:12;22553:23;22580:6;-1:-1:-1;;;;;22580:19:0;22600:4;22580:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22538:67;;;;22623:99;22659:7;22668:10;22623:99;;;;;;;;;;;;;;;;;:35;:99::i;57041:593::-;57207:14;;:::i;:::-;57230:19;47652:1;57252:23;;;:65;;-1:-1:-1;47764:1:0;57279:38;;57252:65;:134;;57385:1;57252:134;;;57334:40;57354:19;:10;57367:6;57354:19;:::i;:::-;57334:15;;:19;:40::i;:::-;57230:156;;;;57393:22;57418:189;57451:4;57464:9;57489:15;57418:189;;57514:11;57534:15;57558:10;57577:23;57595:4;-1:-1:-1;;;;;54625:11:0;54602:7;54625:11;;;:5;:11;;;;;:20;;:27;;54531:127;57577:23;57418:24;:189::i;:::-;57393:214;57041:593;-1:-1:-1;;;;;;;;57041:593:0:o;51924:364::-;52010:7;52040:242;52239:42;52276:4;52247:7;:23;;;-1:-1:-1;;;;;52239:32:0;:36;;:42;;;;:::i;:::-;52195:17;;;;52040:184;;52187:36;;:26;;52218:4;52187:30;:36::i;:::-;52040:132;52133:38;52166:4;52141:7;:19;;;52133:28;;:32;;:38;;;;:::i;:::-;52040:78;52081:36;52113:3;52089:7;:18;;;52081:27;;:31;;:36;;;;:::i;:::-;52048:17;;52040:26;;;:40;:78::i;:::-;:92;;:132::i;6942:712::-;7092:12;7121:7;7117:530;;;-1:-1:-1;7152:10:0;7145:17;;7117:530;7266:17;;:21;7262:374;;7464:10;7458:17;7525:15;7512:10;7508:2;7504:19;7497:44;7262:374;7607:12;7600:20;;-1:-1:-1;;;7600:20:0;;;;;;;;:::i;30753:98::-;30811:7;30838:5;30842:1;30838;:5;:::i;52951:918::-;53180:14;;:::i;:::-;47652:1;53207:23;;53203:228;;;-1:-1:-1;;;;;53241:11:0;;;;;;:5;:11;;;;;:49;;53274:15;;53241:11;:49;;53274:15;;-1:-1:-1;;;;;53241:49:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;53241:49:0;;;;;-1:-1:-1;;;;;53241:49:0;;;;;;53203:228;;;47708:1;53308:38;;;:80;;-1:-1:-1;47764:1:0;53350:38;;53308:80;53304:127;;;-1:-1:-1;;;;;53399:11:0;;;;;;:5;:11;;;;;:24;;-1:-1:-1;;;53399:24:0;;;;;:22;:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;53304:127;53437:44;53448:9;53459:15;53476:4;53437:10;:44::i;:::-;53488:22;53513:288;;;;;;;;53547:9;53513:288;;;;;;53585:10;53513:288;;;;;;53625:11;53513:288;;;;;;53670:15;-1:-1:-1;;;;;53513:288:0;;;;;53707:1;53513:288;;;;;;53729:10;53513:288;;;;;;53766:9;53513:288;;;;;;53792:1;53513:288;;;;;53488:313;;53808:5;:11;53814:4;-1:-1:-1;;;;;53808:11:0;-1:-1:-1;;;;;53808:11:0;;;;;;;;;;;;:20;;53834:7;53808:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53808:34:0;;;;;-1:-1:-1;;;;;53808:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53856:7;53849:14;;;52951:918;;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;203:173:1:-;271:20;;-1:-1:-1;;;;;320:31:1;;310:42;;300:70;;366:1;363;356:12;300:70;203:173;;;:::o;381:808::-;478:6;486;494;502;510;563:3;551:9;542:7;538:23;534:33;531:53;;;580:1;577;570:12;531:53;603:29;622:9;603:29;:::i;:::-;593:39;;651:38;685:2;674:9;670:18;651:38;:::i;:::-;641:48;;736:2;725:9;721:18;708:32;698:42;;791:2;780:9;776:18;763:32;814:18;855:2;847:6;844:14;841:34;;;871:1;868;861:12;841:34;909:6;898:9;894:22;884:32;;954:7;947:4;943:2;939:13;935:27;925:55;;976:1;973;966:12;925:55;1016:2;1003:16;1042:2;1034:6;1031:14;1028:34;;;1058:1;1055;1048:12;1028:34;1103:7;1098:2;1089:6;1085:2;1081:15;1077:24;1074:37;1071:57;;;1124:1;1121;1114:12;1071:57;381:808;;;;-1:-1:-1;381:808:1;;-1:-1:-1;1155:2:1;1147:11;;1177:6;381:808;-1:-1:-1;;;381:808:1:o;2595:180::-;2654:6;2707:2;2695:9;2686:7;2682:23;2678:32;2675:52;;;2723:1;2720;2713:12;2675:52;-1:-1:-1;2746:23:1;;2595:180;-1:-1:-1;2595:180:1:o;2962:316::-;3039:6;3047;3055;3108:2;3096:9;3087:7;3083:23;3079:32;3076:52;;;3124:1;3121;3114:12;3076:52;-1:-1:-1;;3147:23:1;;;3217:2;3202:18;;3189:32;;-1:-1:-1;3268:2:1;3253:18;;;3240:32;;2962:316;-1:-1:-1;2962:316:1:o;3283:159::-;3350:20;;3410:6;3399:18;;3389:29;;3379:57;;3432:1;3429;3422:12;3447:256;3513:6;3521;3574:2;3562:9;3553:7;3549:23;3545:32;3542:52;;;3590:1;3587;3580:12;3542:52;3613:28;3631:9;3613:28;:::i;:::-;3603:38;;3660:37;3693:2;3682:9;3678:18;3660:37;:::i;:::-;3650:47;;3447:256;;;;;:::o;3708:186::-;3767:6;3820:2;3808:9;3799:7;3795:23;3791:32;3788:52;;;3836:1;3833;3826:12;3788:52;3859:29;3878:9;3859:29;:::i;3899:127::-;3960:10;3955:3;3951:20;3948:1;3941:31;3991:4;3988:1;3981:15;4015:4;4012:1;4005:15;4031:255;4103:2;4097:9;4145:6;4133:19;;4182:18;4167:34;;4203:22;;;4164:62;4161:88;;;4229:18;;:::i;:::-;4265:2;4258:22;4031:255;:::o;4291:275::-;4362:2;4356:9;4427:2;4408:13;;-1:-1:-1;;4404:27:1;4392:40;;4462:18;4447:34;;4483:22;;;4444:62;4441:88;;;4509:18;;:::i;:::-;4545:2;4538:22;4291:275;;-1:-1:-1;4291:275:1:o;4571:837::-;4648:6;4656;4709:2;4697:9;4688:7;4684:23;4680:32;4677:52;;;4725:1;4722;4715:12;4677:52;4748:29;4767:9;4748:29;:::i;:::-;4738:39;;4796:2;4849;4838:9;4834:18;4821:32;4872:18;4913:2;4905:6;4902:14;4899:34;;;4929:1;4926;4919:12;4899:34;4967:6;4956:9;4952:22;4942:32;;5012:7;5005:4;5001:2;4997:13;4993:27;4983:55;;5034:1;5031;5024:12;4983:55;5070:2;5057:16;5092:2;5088;5085:10;5082:36;;;5098:18;;:::i;:::-;5140:53;5183:2;5164:13;;-1:-1:-1;;5160:27:1;5156:36;;5140:53;:::i;:::-;5127:66;;5216:2;5209:5;5202:17;5256:7;5251:2;5246;5242;5238:11;5234:20;5231:33;5228:53;;;5277:1;5274;5267:12;5228:53;5332:2;5327;5323;5319:11;5314:2;5307:5;5303:14;5290:45;5376:1;5371:2;5366;5359:5;5355:14;5351:23;5344:34;;5397:5;5387:15;;;;;4571:837;;;;;:::o;5595:529::-;5699:6;5707;5715;5723;5731;5739;5792:3;5780:9;5771:7;5767:23;5763:33;5760:53;;;5809:1;5806;5799:12;5760:53;5832:29;5851:9;5832:29;:::i;:::-;5822:39;5908:2;5893:18;;5880:32;;-1:-1:-1;5959:2:1;5944:18;;5931:32;;6010:2;5995:18;;5982:32;;-1:-1:-1;6061:3:1;6046:19;;6033:33;;-1:-1:-1;6113:3:1;6098:19;6085:33;;-1:-1:-1;5595:529:1;-1:-1:-1;;;5595:529:1:o;6129:254::-;6197:6;6205;6258:2;6246:9;6237:7;6233:23;6229:32;6226:52;;;6274:1;6271;6264:12;6226:52;6297:29;6316:9;6297:29;:::i;:::-;6287:39;6373:2;6358:18;;;;6345:32;;-1:-1:-1;;;6129:254:1:o;6388:1032::-;6530:4;6572:3;6561:9;6557:19;6549:27;;6622:4;6613:6;6607:13;6603:24;6592:9;6585:43;6675:4;6667:6;6663:17;6657:24;6700:10;6766:2;6752:12;6748:21;6741:4;6730:9;6726:20;6719:51;6838:2;6830:4;6822:6;6818:17;6812:24;6808:33;6801:4;6790:9;6786:20;6779:63;;;-1:-1:-1;;;;;6902:4:1;6894:6;6890:17;6884:24;6880:57;6873:4;6862:9;6858:20;6851:87;6987:4;6979:6;6975:17;6969:24;7002:55;7051:4;7040:9;7036:20;7020:14;1572:10;1561:22;1549:35;;1496:94;7002:55;;7106:4;7098:6;7094:17;7088:24;7121:55;7170:4;7159:9;7155:20;7139:14;1477:6;1466:18;1454:31;;1401:90;7121:55;;7225:4;7217:6;7213:17;7207:24;7240:55;7289:4;7278:9;7274:20;7258:14;1477:6;1466:18;1454:31;;1401:90;7240:55;;7344:4;7336:6;7332:17;7326:24;7359:55;7408:4;7397:9;7393:20;7377:14;1671:8;1660:20;1648:33;;1595:92;7359:55;;6388:1032;;;;:::o;7425:254::-;7493:6;7501;7554:2;7542:9;7533:7;7529:23;7525:32;7522:52;;;7570:1;7567;7560:12;7522:52;7606:9;7593:23;7583:33;;7635:38;7669:2;7658:9;7654:18;7635:38;:::i;8742:334::-;8819:6;8827;8835;8888:2;8876:9;8867:7;8863:23;8859:32;8856:52;;;8904:1;8901;8894:12;8856:52;8927:29;8946:9;8927:29;:::i;:::-;8917:39;;8975:38;9009:2;8998:9;8994:18;8975:38;:::i;:::-;8965:48;;9032:38;9066:2;9055:9;9051:18;9032:38;:::i;:::-;9022:48;;8742:334;;;;;:::o;9081:118::-;9167:5;9160:13;9153:21;9146:5;9143:32;9133:60;;9189:1;9186;9179:12;9204:241;9260:6;9313:2;9301:9;9292:7;9288:23;9284:32;9281:52;;;9329:1;9326;9319:12;9281:52;9368:9;9355:23;9387:28;9409:5;9387:28;:::i;9883:326::-;9959:6;9967;9975;10028:2;10016:9;10007:7;10003:23;9999:32;9996:52;;;10044:1;10041;10034:12;9996:52;10067:29;10086:9;10067:29;:::i;:::-;10057:39;;10143:2;10132:9;10128:18;10115:32;10105:42;;10166:37;10199:2;10188:9;10184:18;10166:37;:::i;10214:315::-;10279:6;10287;10340:2;10328:9;10319:7;10315:23;10311:32;10308:52;;;10356:1;10353;10346:12;10308:52;10379:29;10398:9;10379:29;:::i;:::-;10369:39;;10458:2;10447:9;10443:18;10430:32;10471:28;10493:5;10471:28;:::i;:::-;10518:5;10508:15;;;10214:315;;;;;:::o;10766:163::-;10833:20;;10893:10;10882:22;;10872:33;;10862:61;;10919:1;10916;10909:12;10934:179;11001:20;;-1:-1:-1;;;;;11050:38:1;;11040:49;;11030:77;;11103:1;11100;11093:12;11118:161;11185:20;;11245:8;11234:20;;11224:31;;11214:59;;11269:1;11266;11259:12;11284:1044;11377:6;11385;11429:9;11420:7;11416:23;11459:3;11455:2;11451:12;11448:32;;;11476:1;11473;11466:12;11448:32;11512:9;11499:23;11489:33;;11541:6;11581:2;11575;11571:7;11567:2;11563:16;11559:25;11556:45;;;11597:1;11594;11587:12;11556:45;11623:22;;:::i;:::-;11610:35;;11697:2;11686:9;11682:18;11669:32;11745:4;11736:7;11732:18;11723:7;11720:31;11710:59;;11765:1;11762;11755:12;11710:59;11778:22;;11832:37;11865:2;11850:18;;11832:37;:::i;:::-;11827:2;11820:5;11816:14;11809:61;11902:37;11935:2;11924:9;11920:18;11902:37;:::i;:::-;11897:2;11890:5;11886:14;11879:61;11972:38;12005:3;11994:9;11990:19;11972:38;:::i;:::-;11967:2;11960:5;11956:14;11949:62;12044:38;12077:3;12066:9;12062:19;12044:38;:::i;:::-;12038:3;12031:5;12027:15;12020:63;12116:38;12149:3;12138:9;12134:19;12116:38;:::i;:::-;12110:3;12103:5;12099:15;12092:63;12188:38;12221:3;12210:9;12206:19;12188:38;:::i;:::-;12182:3;12175:5;12171:15;12164:63;12260:37;12293:2;12282:9;12278:18;12260:37;:::i;:::-;12254:3;12247:5;12243:15;12236:62;;12317:5;12307:15;;;11284:1044;;;;;:::o;12333:356::-;12535:2;12517:21;;;12554:18;;;12547:30;12613:34;12608:2;12593:18;;12586:62;12680:2;12665:18;;12333:356::o;12986:408::-;13188:2;13170:21;;;13227:2;13207:18;;;13200:30;13266:34;13261:2;13246:18;;13239:62;-1:-1:-1;;;13332:2:1;13317:18;;13310:42;13384:3;13369:19;;12986:408::o;13399:::-;13601:2;13583:21;;;13640:2;13620:18;;;13613:30;13679:34;13674:2;13659:18;;13652:62;-1:-1:-1;;;13745:2:1;13730:18;;13723:42;13797:3;13782:19;;13399:408::o;14104:245::-;14171:6;14224:2;14212:9;14203:7;14199:23;14195:32;14192:52;;;14240:1;14237;14230:12;14192:52;14272:9;14266:16;14291:28;14313:5;14291:28;:::i;15891:127::-;15952:10;15947:3;15943:20;15940:1;15933:31;15983:4;15980:1;15973:15;16007:4;16004:1;15997:15;16795:127;16856:10;16851:3;16847:20;16844:1;16837:31;16887:4;16884:1;16877:15;16911:4;16908:1;16901:15;16927:125;16967:4;16995:1;16992;16989:8;16986:34;;;17000:18;;:::i;:::-;-1:-1:-1;17037:9:1;;16927:125::o;17057:555::-;-1:-1:-1;;;;;17380:15:1;;;17362:34;;17432:15;;;;17427:2;17412:18;;17405:43;17479:2;17464:18;;17457:34;;;;17527:3;17522:2;17507:18;;17500:31;;;17305:4;17547:19;;;17540:30;17342:3;17587:19;;17057:555::o;19080:184::-;19150:6;19203:2;19191:9;19182:7;19178:23;19174:32;19171:52;;;19219:1;19216;19209:12;19171:52;-1:-1:-1;19242:16:1;;19080:184;-1:-1:-1;19080:184:1:o;19953:375::-;-1:-1:-1;;;;;20211:15:1;;;20193:34;;20263:15;;;;20258:2;20243:18;;20236:43;20310:2;20295:18;;20288:34;;;;20143:2;20128:18;;19953:375::o;21514:204::-;21552:3;21588:4;21585:1;21581:12;21620:4;21617:1;21613:12;21655:3;21649:4;21645:14;21640:3;21637:23;21634:49;;;21663:18;;:::i;:::-;21699:13;;21514:204;-1:-1:-1;;;21514:204:1:o;23723:127::-;23784:10;23779:3;23775:20;23772:1;23765:31;23815:4;23812:1;23805:15;23839:4;23836:1;23829:15;23855:120;23895:1;23921;23911:35;;23926:18;;:::i;:::-;-1:-1:-1;23960:9:1;;23855:120::o;23980:112::-;24012:1;24038;24028:35;;24043:18;;:::i;:::-;-1:-1:-1;24077:9:1;;23980:112::o;24097:168::-;24137:7;24203:1;24199;24195:6;24191:14;24188:1;24185:21;24180:1;24173:9;24166:17;24162:45;24159:71;;;24210:18;;:::i;:::-;-1:-1:-1;24250:9:1;;24097:168::o;26863:128::-;26903:3;26934:1;26930:6;26927:1;26924:13;26921:39;;;26940:18;;:::i;:::-;-1:-1:-1;26976:9:1;;26863:128::o;26996:407::-;27198:2;27180:21;;;27237:2;27217:18;;;27210:30;27276:34;27271:2;27256:18;;27249:62;-1:-1:-1;;;27342:2:1;27327:18;;27320:41;27393:3;27378:19;;26996:407::o;28577:244::-;28616:3;-1:-1:-1;;;;;28697:2:1;28694:1;28690:10;28727:2;28724:1;28720:10;28758:3;28754:2;28750:12;28745:3;28742:21;28739:47;;;28766:18;;:::i;:::-;28802:13;;28577:244;-1:-1:-1;;;;28577:244:1:o;28826:197::-;28864:3;28892:6;28933:2;28926:5;28922:14;28960:2;28951:7;28948:15;28945:41;;;28966:18;;:::i;:::-;29015:1;29002:15;;28826:197;-1:-1:-1;;;28826:197:1:o;29028:181::-;29066:3;29110:6;29103:5;29099:18;29136:7;29126:41;;29147:18;;:::i;:::-;-1:-1:-1;;29183:20:1;;29028:181;-1:-1:-1;;29028:181:1:o;29978:217::-;30017:4;30046:6;30102:10;;;;30072;;30124:12;;;30121:38;;;30139:18;;:::i;:::-;30176:13;;29978:217;-1:-1:-1;;;29978:217:1:o;30200:224::-;30239:3;30267:6;30300:2;30297:1;30293:10;30330:2;30327:1;30323:10;30361:3;30357:2;30353:12;30348:3;30345:21;30342:47;;;30369:18;;:::i;31238:258::-;31310:1;31320:113;31334:6;31331:1;31328:13;31320:113;;;31410:11;;;31404:18;31391:11;;;31384:39;31356:2;31349:10;31320:113;;;31451:6;31448:1;31445:13;31442:48;;;-1:-1:-1;;31486:1:1;31468:16;;31461:27;31238:258::o;31501:274::-;31630:3;31668:6;31662:13;31684:53;31730:6;31725:3;31718:4;31710:6;31706:17;31684:53;:::i;:::-;31753:16;;;;;31501:274;-1:-1:-1;;31501:274:1:o;31780:383::-;31929:2;31918:9;31911:21;31892:4;31961:6;31955:13;32004:6;31999:2;31988:9;31984:18;31977:34;32020:66;32079:6;32074:2;32063:9;32059:18;32054:2;32046:6;32042:15;32020:66;:::i;:::-;32147:2;32126:15;-1:-1:-1;;32122:29:1;32107:45;;;;32154:2;32103:54;;31780:383;-1:-1:-1;;31780:383:1:o
Swarm Source
ipfs://cc1e8962afef2bbe079320ca5d0dc31e086d40877a90a53160324ca88ad6cabd
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.