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
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x61014060 | 20068543 | 43 days ago | IN | Create: FiasPrivateVesting | 0 ETH | 0.02782629 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
FiasPrivateVesting
Compiler Version
v0.8.25+commit.b61c2a91
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-06-11 */ pragma solidity ^0.8.12; interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval( address indexed owner, address indexed spender, uint256 value ); } library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } else if (error == RecoverError.InvalidSignatureV) { revert("ECDSA: invalid signature 'v' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { // Check the signature length // - case 65: r,s,v signature (standard) // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._ if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else if (signature.length == 64) { bytes32 r; bytes32 vs; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) vs := mload(add(signature, 0x40)) } return tryRecover(hash, r, vs); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32( 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if ( uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 ) { return (address(0), RecoverError.InvalidSignatureS); } if (v != 27 && v != 28) { return (address(0), RecoverError.InvalidSignatureV); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256( abi.encodePacked("\x19Ethereum Signed Message:\n32", hash) ); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256( abi.encodePacked( "\x19Ethereum Signed Message:\n", Strings.toString(s.length), s ) ); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256( abi.encodePacked("\x19\x01", domainSeparator, structHash) ); } } 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 functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _CACHED_DOMAIN_SEPARATOR; uint256 private immutable _CACHED_CHAIN_ID; address private immutable _CACHED_THIS; bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { bytes32 hashedName = keccak256(bytes(name)); bytes32 hashedVersion = keccak256(bytes(version)); bytes32 typeHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); _HASHED_NAME = hashedName; _HASHED_VERSION = hashedVersion; _CACHED_CHAIN_ID = block.chainid; _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator( typeHash, hashedName, hashedVersion ); _CACHED_THIS = address(this); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if ( address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID ) { return _CACHED_DOMAIN_SEPARATOR; } else { return _buildDomainSeparator( _TYPE_HASH, _HASHED_NAME, _HASHED_VERSION ); } } function _buildDomainSeparator( bytes32 typeHash, bytes32 nameHash, bytes32 versionHash ) private view returns (bytes32) { return keccak256( abi.encode( typeHash, nameHash, versionHash, block.chainid, address(this) ) ); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash); } } abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Internal function that returns the initialized version. Returns `_initialized` */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Internal function that returns the initialized version. Returns `_initializing` */ function _isInitializing() internal view returns (bool) { return _initializing; } } 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; } 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) internal 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; } abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @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; } interface IERC20PermitUpgradeable { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } interface IERC20Upgradeable { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.8.12; contract whitelistChecker is EIP712 { string private constant SIGNING_DOMAIN = "DevvE_LAUNCHPAD"; string private constant SIGNATURE_VERSION = "1"; struct Signer { address userAddress; address contractAddress; uint256 id; uint256 timestamp; bytes signature; } constructor() EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {} function getSigner(Signer memory whitelist) public view returns (address) { return _verify(whitelist); } /// @notice Returns a hash of the given whitelist, prepared using EIP712 typed data hashing rules. function _hash(Signer memory whitelist) internal view returns (bytes32) { return _hashTypedDataV4( keccak256( abi.encode( keccak256( "Signer(address userAddress,address contractAddress,uint256 id,uint256 timestamp)" ), whitelist.userAddress, whitelist.contractAddress, whitelist.id, whitelist.timestamp ) ) ); } function _verify(Signer memory whitelist) internal view returns (address) { bytes32 digest = _hash(whitelist); return ECDSA.recover(digest, whitelist.signature); } } library SafeERC20Upgradeable { using AddressUpgradeable for address; function safeTransfer( IERC20Upgradeable token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20Upgradeable token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20Upgradeable token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20PermitUpgradeable token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract FiasPrivateVesting is OwnableUpgradeable, whitelistChecker ,ReentrancyGuardUpgradeable{ using SafeERC20Upgradeable for IERC20Upgradeable; IERC20Upgradeable public token; address public signer; bool private isStart; bool private iscollect; bool private ischeck; uint256 public activeLockDate; uint256 public totalDepositTokens; uint256 public totalAllocatedamount; uint256 public totalAirdropAllocationamount; uint256 public vestingEndTime; mapping(address=>mapping(uint=>bool)) public usedNonce; mapping (address => bool) public isUserAdded; mapping (address => bool) public isAirdropUserAdded; mapping(address => InvestorDetails) public Investors; address private pendingOwner; uint256 day; event TokenWithdraw(address indexed buyer, uint256 value,uint256 id); event RecoverToken(address indexed token, uint256 indexed amount); event RemoveUser(address _userAddress); event InvestorAddress(address account, uint256 _amout); event startDate(uint256 date); event setTokens(address _userAddress); event OwnershipTransferInitiated(address indexed currentOwner, address indexed pendingOwner); modifier setDate() { require(isStart == true, "wait for start date"); _; } modifier _iscollect() { require(iscollect == true, "wait"); _; } modifier check() { require(ischeck == true); _; } uint256 public TGEStartDate; uint256 public lockEndDate; uint256 public totalLinearUnits; uint256 public initialPercentage; uint256 public intermediaryPercentage; uint256 public intermediateTime; uint256 private middleTime; uint256 private linearTime; uint256 vestingPeriodDays = 12 * 30; // 12 months * 30 days receive() external payable {} function getInvestorDetails(address _addr)public view returns (InvestorDetails memory) { return Investors[_addr]; } function getContractTokenBalance() public view returns (uint256) { return token.balanceOf(address(this)); } function setSigner(address _addr) public onlyOwner { signer = _addr; } function remainningTokens() external view returns (uint256) { return totalDepositTokens - totalAllocatedamount; } struct Investor { address account; uint256 amount; } struct InvestorDetails { uint256 totalBalance; uint256 timeDifference; uint256 lastVestedTime; uint256 reminingUnitsToVest; uint256 tokensPerUnit; uint256 vestingBalance; uint256 lastWithdrawalTimestamp; uint256 initialAmount; uint256 nextAmount; bool isInitialAmountClaimed; } // Adds details of a new investor function addInvestorDetails(uint amount, Signer memory _signer ) public nonReentrant{ require(!usedNonce[msg.sender][_signer.timestamp],"Nonce : Invalid Nonce"); require(getSigner(_signer) == signer, "Invalid Signer"); require (!isUserAdded[msg.sender],'User already added'); usedNonce[msg.sender][_signer.timestamp]=true; isUserAdded[msg.sender] = true; InvestorDetails memory investor; investor.totalBalance = amount; investor.vestingBalance = investor.totalBalance; investor.reminingUnitsToVest = totalLinearUnits; investor.initialAmount =((investor.totalBalance) * (initialPercentage)) /100; investor.nextAmount =((investor.totalBalance) * (intermediaryPercentage)) /100; investor.tokensPerUnit = ((investor.totalBalance) - (investor.initialAmount) - (investor.nextAmount)) /totalLinearUnits; if(investor.initialAmount == 0 && investor.nextAmount == 0){ investor.isInitialAmountClaimed = true; } Investors[_signer.userAddress] = investor; totalAllocatedamount += investor.totalBalance; emit InvestorAddress(msg.sender,amount); } // Allows the admin to add multiple investors function addInvestorsbyadmin(Investor[] memory vest) external onlyOwner nonReentrant{ require(vest.length<=50,"Max Length Reached"); for (uint i = 0;i < vest.length;i++) { require (!isUserAdded[vest[i].account],'User already added'); isUserAdded[vest[i].account] = true; InvestorDetails memory investor; investor.totalBalance = vest[i].amount; investor.vestingBalance = investor.totalBalance; investor.reminingUnitsToVest = totalLinearUnits; investor.initialAmount =((investor.totalBalance) * (initialPercentage)) /100; investor.nextAmount =((investor.totalBalance) * (intermediaryPercentage)) /100; investor.tokensPerUnit = ((investor.totalBalance) - (investor.initialAmount) - (investor.nextAmount)) /totalLinearUnits; if(investor.initialAmount == 0 && investor.nextAmount == 0){ investor.isInitialAmountClaimed = true; } Investors[vest[i].account] = investor; totalAllocatedamount += investor.totalBalance; emit InvestorAddress(vest[i].account,vest[i].amount); } } // Removes a single user from a specific project. function removeSingleUser(address _userAddress)public onlyOwner{ require(isUserAdded[_userAddress],"Not a Investor"); delete Investors[_userAddress]; isUserAdded[_userAddress]=false; emit RemoveUser(_userAddress); } //Allows the withdrawal of a specified amount of tokens from the contract. function withdrawTokenfunction(Signer memory _signer) external nonReentrant{ require(isStart = true, "wait for start date"); require(block.timestamp >= TGEStartDate, "TGE has not started yet"); require(!usedNonce[msg.sender][_signer.timestamp],"Nonce : Invalid Nonce"); require(getSigner(_signer) == signer, "Invalid Signer"); usedNonce[msg.sender][_signer.timestamp]=true; uint256 id = 1; uint256 lineartoken = withdrawTokens(); uint256 totaltokens = lineartoken;// airdroptoekns + lineartoken; require(totaltokens > 0, "wait for start date"); token.safeTransfer(msg.sender, totaltokens); emit TokenWithdraw(msg.sender, totaltokens,id); } function withdrawTokens() internal setDate returns (uint256) { if (Investors[msg.sender].isInitialAmountClaimed) { if (block.timestamp >= lockEndDate) { activeLockDate = lockEndDate; /* Time difference to calculate the interval between now and last vested time. */ uint256 timeDifference; if (Investors[msg.sender].lastVestedTime == 0) { if (activeLockDate == 0) { return 0; // Active lockdate was zero } timeDifference = block.timestamp - activeLockDate; } else { timeDifference = block.timestamp - Investors[msg.sender].lastVestedTime; } uint256 numberOfUnitsCanBeVested = timeDifference / day; /* Remaining units to vest should be greater than 0 */ if (Investors[msg.sender].reminingUnitsToVest == 0) { return 0; // All units vested! } /* Number of units can be vested should be more than 0 */ if (numberOfUnitsCanBeVested == 0) { return 0; // Please wait till next vesting period! } if ( numberOfUnitsCanBeVested >= Investors[msg.sender].reminingUnitsToVest ) { numberOfUnitsCanBeVested = Investors[msg.sender] .reminingUnitsToVest; } uint256 tokenToTransfer = numberOfUnitsCanBeVested * Investors[msg.sender].tokensPerUnit; uint256 remainingUnits = Investors[msg.sender] .reminingUnitsToVest; uint256 balance = Investors[msg.sender].vestingBalance; Investors[msg.sender] .reminingUnitsToVest -= numberOfUnitsCanBeVested; Investors[msg.sender].vestingBalance -= numberOfUnitsCanBeVested * Investors[msg.sender].tokensPerUnit; Investors[msg.sender].lastVestedTime = block.timestamp; Investors[msg.sender].lastWithdrawalTimestamp = block.timestamp; if (numberOfUnitsCanBeVested == remainingUnits) { return balance; } else { return tokenToTransfer; } } else { return 0; // Wait until lock period completes } } else { if (block.timestamp > intermediateTime) { if (iscollect == true) { Investors[msg.sender].vestingBalance -= Investors[ msg.sender ].nextAmount; Investors[msg.sender].isInitialAmountClaimed = true; uint256 amount = Investors[msg.sender].nextAmount; Investors[msg.sender].lastWithdrawalTimestamp = block.timestamp; return amount; } else { Investors[msg.sender].vestingBalance -= Investors[msg.sender].nextAmount + Investors[msg.sender].initialAmount; Investors[msg.sender].isInitialAmountClaimed = true; uint256 amount = Investors[msg.sender].nextAmount + Investors[msg.sender].initialAmount; Investors[msg.sender].lastWithdrawalTimestamp = block.timestamp; return amount; } } else { if (Investors[msg.sender].isInitialAmountClaimed) { return 0; // Amount already withdrawn } if (block.timestamp <= TGEStartDate) { return 0; // Wait Until the Start Date } if (Investors[msg.sender].initialAmount == 0) { return 0; // Wait for next vest time } iscollect = true; uint256 amount = Investors[msg.sender].initialAmount; Investors[msg.sender].vestingBalance -= Investors[msg.sender] .initialAmount; Investors[msg.sender].initialAmount = 0; Investors[msg.sender].lastWithdrawalTimestamp = block.timestamp; return amount; } } } // Allows the deposit of a specified amount of tokens into the contract. function depositToken(uint256 amount) public { token.safeTransferFrom(msg.sender, address(this), amount); totalDepositTokens += amount; } function recoverTokens(address _token,address _userAddress,uint256 amount) public onlyOwner { IERC20Upgradeable(_token).transfer(_userAddress, amount); emit RecoverToken(_token, amount); } function getAvailableBalance(address _addr)public view returns (uint256,uint256,uint256) { if (Investors[_addr].isInitialAmountClaimed) { if (block.timestamp >= lockEndDate) { uint256 lockDate = lockEndDate; uint256 hello = day; uint256 timeDifference; if (Investors[_addr].lastVestedTime == 0) { if(lockEndDate == 0) return (0, 0, 0); timeDifference = (block.timestamp) - (lockDate); } else { timeDifference =(block.timestamp) - (Investors[_addr].lastVestedTime); } if (Investors[_addr].reminingUnitsToVest == 0) { return (0, 0, 0); // All units vested! } uint256 numberOfUnitsCanBeVested; uint256 tokenToTransfer; numberOfUnitsCanBeVested = (timeDifference) / (hello); if (numberOfUnitsCanBeVested >= Investors[_addr].reminingUnitsToVest) { numberOfUnitsCanBeVested = Investors[_addr].reminingUnitsToVest; } tokenToTransfer = numberOfUnitsCanBeVested * Investors[_addr].tokensPerUnit; uint256 reminingUnits = Investors[_addr].reminingUnitsToVest; uint256 balance = Investors[_addr].vestingBalance; if (numberOfUnitsCanBeVested == reminingUnits) return (balance, 0, 0); else return (tokenToTransfer, reminingUnits, balance); }else{ return (0, 0, 0); } } else { if (block.timestamp > intermediateTime) { if (iscollect) { Investors[_addr].nextAmount == 0; return (Investors[_addr].nextAmount, 0, 0); } else { if (ischeck) return (0, 0, 0); ischeck == true; return ( (Investors[_addr].nextAmount + Investors[_addr].initialAmount), 0, 0 ); } } else { if (block.timestamp < TGEStartDate) { return (0, 0, 0); } else { iscollect == true; Investors[_addr].initialAmount == 0; return (Investors[_addr].initialAmount, 0, 0); } } } } //Sets the vesting start date function setStartDate(uint256 _startDate) external onlyOwner { TGEStartDate = _startDate; intermediateTime = _startDate + middleTime * 1 days; lockEndDate = intermediateTime + linearTime * 1 days; vestingEndTime = lockEndDate + totalLinearUnits * day; emit startDate (_startDate); } //Sets the address of the ERC-20 token contract to be used by the platform. function setToken(address _token) external onlyOwner { require(_token != address(0), "Invalid Token Address"); token = IERC20Upgradeable(_token); emit setTokens (_token); } function initialize(address Signer,uint256 _totalLinearUnits,uint256 timeBetweenUnits, uint256 linearStartDate, uint256 _startDate, address _tokenAddress, uint256 _initialPercentage, uint256 _intermediatePercentage, uint256 _intermediateTime) external initializer{ require(_tokenAddress != address(0)); middleTime = _intermediateTime; linearTime = linearStartDate; token = IERC20Upgradeable(_tokenAddress); totalLinearUnits = _totalLinearUnits; day = timeBetweenUnits * 1 days; TGEStartDate = _startDate; initialPercentage = _initialPercentage; intermediaryPercentage = _intermediatePercentage; intermediateTime = _startDate + middleTime * 1 days; lockEndDate = intermediateTime + linearTime * 1 days; isStart = true; signer = Signer; vestingEndTime = lockEndDate + _totalLinearUnits * timeBetweenUnits * 1 days; __Ownable_init(); __ReentrancyGuard_init(); } modifier onlyPendingOwner() { require(msg.sender == pendingOwner, "Caller is not the pending owner"); _; } // Function to initiate ownership transfer function initiateOwnershipTransfer(address newOwner) external onlyOwner { require(newOwner != address(0), "Invalid Wallet Address"); pendingOwner = newOwner; emit OwnershipTransferInitiated(owner(), pendingOwner); } // Function to confirm ownership transfer function confirmOwnershipTransfer() external onlyPendingOwner { _transferOwnership(pendingOwner); pendingOwner = address(0); // Reset pending owner } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amout","type":"uint256"}],"name":"InvestorAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"currentOwner","type":"address"},{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipTransferInitiated","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":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoverToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_userAddress","type":"address"}],"name":"RemoveUser","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"TokenWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_userAddress","type":"address"}],"name":"setTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"date","type":"uint256"}],"name":"startDate","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Investors","outputs":[{"internalType":"uint256","name":"totalBalance","type":"uint256"},{"internalType":"uint256","name":"timeDifference","type":"uint256"},{"internalType":"uint256","name":"lastVestedTime","type":"uint256"},{"internalType":"uint256","name":"reminingUnitsToVest","type":"uint256"},{"internalType":"uint256","name":"tokensPerUnit","type":"uint256"},{"internalType":"uint256","name":"vestingBalance","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawalTimestamp","type":"uint256"},{"internalType":"uint256","name":"initialAmount","type":"uint256"},{"internalType":"uint256","name":"nextAmount","type":"uint256"},{"internalType":"bool","name":"isInitialAmountClaimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TGEStartDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeLockDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"_signer","type":"tuple"}],"name":"addInvestorDetails","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct FiasPrivateVesting.Investor[]","name":"vest","type":"tuple[]"}],"name":"addInvestorsbyadmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"confirmOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getAvailableBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getContractTokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getInvestorDetails","outputs":[{"components":[{"internalType":"uint256","name":"totalBalance","type":"uint256"},{"internalType":"uint256","name":"timeDifference","type":"uint256"},{"internalType":"uint256","name":"lastVestedTime","type":"uint256"},{"internalType":"uint256","name":"reminingUnitsToVest","type":"uint256"},{"internalType":"uint256","name":"tokensPerUnit","type":"uint256"},{"internalType":"uint256","name":"vestingBalance","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawalTimestamp","type":"uint256"},{"internalType":"uint256","name":"initialAmount","type":"uint256"},{"internalType":"uint256","name":"nextAmount","type":"uint256"},{"internalType":"bool","name":"isInitialAmountClaimed","type":"bool"}],"internalType":"struct FiasPrivateVesting.InvestorDetails","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"whitelist","type":"tuple"}],"name":"getSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"Signer","type":"address"},{"internalType":"uint256","name":"_totalLinearUnits","type":"uint256"},{"internalType":"uint256","name":"timeBetweenUnits","type":"uint256"},{"internalType":"uint256","name":"linearStartDate","type":"uint256"},{"internalType":"uint256","name":"_startDate","type":"uint256"},{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_initialPercentage","type":"uint256"},{"internalType":"uint256","name":"_intermediatePercentage","type":"uint256"},{"internalType":"uint256","name":"_intermediateTime","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"initiateOwnershipTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"intermediaryPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"intermediateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isAirdropUserAdded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isUserAdded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockEndDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"remainningTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"}],"name":"removeSingleUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startDate","type":"uint256"}],"name":"setStartDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAirdropAllocationamount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocatedamount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDepositTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLinearUnits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"usedNonce","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct whitelistChecker.Signer","name":"_signer","type":"tuple"}],"name":"withdrawTokenfunction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
61014060405261016860ac55348015610016575f80fd5b50604080518082018252600f81526e11195d9d9157d310555390d2141051608a1b6020808301918252835180850190945260018452603160f81b908401528151902060e08190527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc66101008190524660a0529192917f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6100fa8184846040805160208101859052908101839052606081018290524660808201523060a08201525f9060c0016040516020818303038152906040528051906020012090509392505050565b6080523060c052610120525061010f92505050565b60805160a05160c05160e0516101005161012051612e8b6101565f395f6125eb01525f61263a01525f61261501525f61256e01525f61259801525f6125c20152612e8b5ff3fe6080604052600436106101ff575f3560e01c806372b6068211610113578063b798fd511161009d578063cbe97e351161006d578063cbe97e351461059b578063e8930efd146105b0578063efab1e5014610669578063f90a2f3014610695578063fc0c546a146106ce575f80fd5b8063b798fd5114610529578063bf7c6e981461053e578063c03695c61461055d578063c0b6f5611461057c575f80fd5b80638da5cb5b116100e35780638da5cb5b146104b85780639beaa683146104d5578063a70ed370146104ea578063af0cceeb146104ff578063b4c3a93314610514575f80fd5b806372b606821461045057806382d95df514610465578063840cec511461048457806386fab45e146104a3575f80fd5b80634c958a9b116101945780635f3e849f116101645780635f3e849f146103a55780636215be77146103c45780636c19e783146103e35780636c24a76f146104025780637200b8291461043c575f80fd5b80634c958a9b1461033e578063507077b114610352578063525f50f014610367578063540c101114610386575f80fd5b8063238ac933116101cf578063238ac933146102bf578063317d9453146102f657806337fd2f3a1461030a5780633d5336c71461031f575f80fd5b806307358e7f1461020a578063083aa0961461024d57806310f8ec4914610270578063144fa6d71461029e575f80fd5b3661020657005b5f80fd5b348015610215575f80fd5b506102386102243660046128a8565b60a06020525f908152604090205460ff1681565b60405190151581526020015b60405180910390f35b348015610258575f80fd5b50610262609b5481565b604051908152602001610244565b34801561027b575f80fd5b5061023861028a3660046128a8565b609f6020525f908152604090205460ff1681565b3480156102a9575f80fd5b506102bd6102b83660046128a8565b6106ed565b005b3480156102ca575f80fd5b506098546102de906001600160a01b031681565b6040516001600160a01b039091168152602001610244565b348015610301575f80fd5b506102626107c3565b348015610315575f80fd5b5061026260a95481565b34801561032a575f80fd5b506102bd610339366004612a21565b610832565b348015610349575f80fd5b50610262610a3d565b34801561035d575f80fd5b50610262609c5481565b348015610372575f80fd5b506102bd610381366004612a53565b610a4e565b348015610391575f80fd5b506102de6103a0366004612a21565b610c4c565b3480156103b0575f80fd5b506102bd6103bf366004612ac4565b610c5c565b3480156103cf575f80fd5b506102bd6103de366004612afd565b610d31565b3480156103ee575f80fd5b506102bd6103fd3660046128a8565b610d62565b34801561040d575f80fd5b5061042161041c3660046128a8565b610dae565b60408051938452602084019290925290820152606001610244565b348015610447575f80fd5b506102bd611034565b34801561045b575f80fd5b5061026260a55481565b348015610470575f80fd5b506102bd61047f366004612afd565b6110b5565b34801561048f575f80fd5b506102bd61049e3660046128a8565b611171565b3480156104ae575f80fd5b50610262609d5481565b3480156104c3575f80fd5b506033546001600160a01b03166102de565b3480156104e0575f80fd5b5061026260a45481565b3480156104f5575f80fd5b5061026260a65481565b34801561050a575f80fd5b50610262609a5481565b34801561051f575f80fd5b5061026260995481565b348015610534575f80fd5b5061026260a75481565b348015610549575f80fd5b506102bd610558366004612b14565b611293565b348015610568575f80fd5b506102bd610577366004612bd6565b61160f565b348015610587575f80fd5b506102bd6105963660046128a8565b611904565b3480156105a6575f80fd5b5061026260a85481565b3480156105bb575f80fd5b5061061d6105ca3660046128a8565b60a16020525f908152604090208054600182015460028301546003840154600485015460058601546006870154600788015460088901546009909901549798969795969495939492939192909160ff168a565b604080519a8b5260208b0199909952978901969096526060880194909452608087019290925260a086015260c085015260e0840152610100830152151561012082015261014001610244565b348015610674575f80fd5b506106886106833660046128a8565b6119e6565b6040516102449190612c1a565b3480156106a0575f80fd5b506102386106af366004612c94565b609e60209081525f928352604080842090915290825290205460ff1681565b3480156106d9575f80fd5b506097546102de906001600160a01b031681565b6033546001600160a01b031633146107205760405162461bcd60e51b815260040161071790612cbc565b60405180910390fd5b6001600160a01b03811661076e5760405162461bcd60e51b8152602060048201526015602482015274496e76616c696420546f6b656e204164647265737360581b6044820152606401610717565b609780546001600160a01b0319166001600160a01b0383169081179091556040519081527fa639eb4d8d762effb9991c1c8bbafe6907a67c973ca3069761cd4196c3a2cca5906020015b60405180910390a150565b6097546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015610809573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061082d9190612cf1565b905090565b61083a611a7f565b6098805460ff60a01b1916600160a01b17905560a45442101561089f5760405162461bcd60e51b815260206004820152601760248201527f54474520686173206e6f742073746172746564207965740000000000000000006044820152606401610717565b335f908152609e602090815260408083206060850151845290915290205460ff16156109055760405162461bcd60e51b81526020600482015260156024820152744e6f6e6365203a20496e76616c6964204e6f6e636560581b6044820152606401610717565b6098546001600160a01b031661091a82610c4c565b6001600160a01b0316146109615760405162461bcd60e51b815260206004820152600e60248201526d24b73b30b634b21029b4b3b732b960911b6044820152606401610717565b335f908152609e60209081526040808320606085015184529091528120805460ff1916600190811790915590610995611ad8565b905080806109db5760405162461bcd60e51b81526020600482015260136024820152727761697420666f72207374617274206461746560681b6044820152606401610717565b6097546109f2906001600160a01b03163383611eb2565b604080518281526020810185905233917fa50d41d074ce94f4240b13344e911203e7a2169e7f09812a0d70a882e7c633c7910160405180910390a2505050610a3a6001606555565b50565b5f609b54609a5461082d9190612d1c565b5f54610100900460ff1615808015610a6c57505f54600160ff909116105b80610a855750303b158015610a8557505f5460ff166001145b610ae85760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610717565b5f805460ff191660011790558015610b09575f805461ff0019166101001790555b6001600160a01b038516610b1b575f80fd5b60aa82905560ab879055609780546001600160a01b0319166001600160a01b03871617905560a6899055610b528862015180612d2f565b60a35560a486905560a784905560a883905560aa54610b749062015180612d2f565b610b7e9087612d46565b60a95560ab54610b919062015180612d2f565b60a954610b9e9190612d46565b60a555609880546001600160a01b038c166001600160a81b031990911617600160a01b179055610bce888a612d2f565b610bdb9062015180612d2f565b60a554610be89190612d46565b609d55610bf3611f21565b610bfb611f51565b8015610c40575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050505050505050565b5f610c5682611f7f565b92915050565b6033546001600160a01b03163314610c865760405162461bcd60e51b815260040161071790612cbc565b60405163a9059cbb60e01b81526001600160a01b0383811660048301526024820183905284169063a9059cbb906044016020604051808303815f875af1158015610cd2573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610cf69190612d59565b5060405181906001600160a01b038516907ffba2d3bdfb2d601eb66a89783a2c614856101cadce71556753c2edadd60c831c905f90a3505050565b609754610d49906001600160a01b0316333084611fa1565b80609a5f828254610d5a9190612d46565b909155505050565b6033546001600160a01b03163314610d8c5760405162461bcd60e51b815260040161071790612cbc565b609880546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b0381165f90815260a160205260408120600901548190819060ff1615610f5c5760a5544210610f4f5760a55460a3546001600160a01b0386165f90815260a160205260408120600201548103610e305760a5545f03610e1f575f805f95509550955050505061102d565b610e298342612d1c565b9050610e58565b6001600160a01b0387165f90815260a16020526040902060020154610e559042612d1c565b90505b6001600160a01b0387165f90815260a160205260408120600301549003610e8a575f805f95509550955050505061102d565b5f80610e968484612d78565b6001600160a01b038a165f90815260a160205260409020600301549092508210610ed8576001600160a01b0389165f90815260a1602052604090206003015491505b6001600160a01b0389165f90815260a16020526040902060040154610efd9083612d2f565b6001600160a01b038a165f90815260a160205260409020600381015460059091015491925090818403610f3e5798505f975087965061102d95505050505050565b9198509650945061102d9350505050565b505f91508190508061102d565b60a954421115610ff557609854600160a81b900460ff1615610f9d575050506001600160a01b0381165f90815260a16020526040812060080154908061102d565b609854600160b01b900460ff1615610fbc57505f91508190508061102d565b6001600160a01b0384165f90815260a1602052604090206007810154600890910154610fe89190612d46565b5f8092509250925061102d565b60a45442101561100c57505f91508190508061102d565b5050506001600160a01b0381165f90815260a1602052604081206007015490805b9193909250565b60a2546001600160a01b0316331461108e5760405162461bcd60e51b815260206004820152601f60248201527f43616c6c6572206973206e6f74207468652070656e64696e67206f776e6572006044820152606401610717565b60a2546110a3906001600160a01b0316611fdf565b60a280546001600160a01b0319169055565b6033546001600160a01b031633146110df5760405162461bcd60e51b815260040161071790612cbc565b60a481905560aa546110f49062015180612d2f565b6110fe9082612d46565b60a95560ab546111119062015180612d2f565b60a95461111e9190612d46565b60a55560a35460a6546111319190612d2f565b60a55461113e9190612d46565b609d556040518181527f41d92cd959b603c2e36558458aa40a7fc67ef98712fc8ca8e34c76c87349cf06906020016107b8565b6033546001600160a01b0316331461119b5760405162461bcd60e51b815260040161071790612cbc565b6001600160a01b0381165f908152609f602052604090205460ff166111f35760405162461bcd60e51b815260206004820152600e60248201526d2737ba10309024b73b32b9ba37b960911b6044820152606401610717565b6001600160a01b0381165f81815260a1602090815260408083208381556001810184905560028101849055600381018490556004810184905560058101849055600681018490556007810184905560088101849055600901805460ff19908116909155609f835292819020805490931690925590519182527f0ad8e54ac59bf2d8a7a1474c1af503b593553cf4fcaaffdef04ab5249f89762b91016107b8565b6033546001600160a01b031633146112bd5760405162461bcd60e51b815260040161071790612cbc565b6112c5611a7f565b60328151111561130c5760405162461bcd60e51b815260206004820152601260248201527113585e0813195b99dd1a0814995858da195960721b6044820152606401610717565b5f5b815181101561160457609f5f83838151811061132c5761132c612d97565b602090810291909101810151516001600160a01b031682528101919091526040015f205460ff16156113955760405162461bcd60e51b8152602060048201526012602482015271155cd95c88185b1c9958591e48185919195960721b6044820152606401610717565b6001609f5f8484815181106113ac576113ac612d97565b602090810291909101810151516001600160a01b031682528101919091526040015f20805460ff19169115159190911790556113e6612842565b8282815181106113f8576113f8612d97565b602090810291909101810151015180825260a0820181905260a654606083015260a7546064916114289190612d2f565b6114329190612d78565b60e082015260a854815160649161144891612d2f565b6114529190612d78565b610100820181905260a65460e083015183519192916114719190612d1c565b61147b9190612d1c565b6114859190612d78565b608082015260e081015115801561149f5750610100810151155b156114ad5760016101208201525b8060a15f8585815181106114c3576114c3612d97565b602090810291909101810151516001600160a01b031682528181019290925260409081015f90812084518155928401516001840155908301516002830155606083015160038301556080830151600483015560a0830151600583015560c0830151600683015560e083015160078301556101008301516008830155610120909201516009909101805460ff19169115159190911790558151609b80549192909161156e908490612d46565b925050819055507fa7ac2c446ae8e2018af903ad70f68d8a72d6a5fe1579ab4a4f9cf5d1ce3e6ca38383815181106115a8576115a8612d97565b60200260200101515f01518484815181106115c5576115c5612d97565b6020026020010151602001516040516115f39291906001600160a01b03929092168252602082015260400190565b60405180910390a15060010161130e565b50610a3a6001606555565b611617611a7f565b335f908152609e602090815260408083206060850151845290915290205460ff161561167d5760405162461bcd60e51b81526020600482015260156024820152744e6f6e6365203a20496e76616c6964204e6f6e636560581b6044820152606401610717565b6098546001600160a01b031661169282610c4c565b6001600160a01b0316146116d95760405162461bcd60e51b815260206004820152600e60248201526d24b73b30b634b21029b4b3b732b960911b6044820152606401610717565b335f908152609f602052604090205460ff161561172d5760405162461bcd60e51b8152602060048201526012602482015271155cd95c88185b1c9958591e48185919195960721b6044820152606401610717565b335f818152609e602090815260408083206060860151845282528083208054600160ff199182168117909255948452609f9092529091208054909216179055611774612842565b82815260a0810183905260a654606082015260a7546064906117969085612d2f565b6117a09190612d78565b60e082015260a85481516064916117b691612d2f565b6117c09190612d78565b610100820181905260a65460e083015183519192916117df9190612d1c565b6117e99190612d1c565b6117f39190612d78565b608082015260e081015115801561180d5750610100810151155b1561181b5760016101208201525b81516001600160a01b03165f90815260a1602090815260408083208451808255928501516001820155908401516002820155606084015160038201556080840151600482015560a0840151600582015560c0840151600682015560e0840151600782015561010084015160088201556101208401516009909101805460ff1916911515919091179055609b8054919290916118b7908490612d46565b909155505060408051338152602081018590527fa7ac2c446ae8e2018af903ad70f68d8a72d6a5fe1579ab4a4f9cf5d1ce3e6ca3910160405180910390a1506119006001606555565b5050565b6033546001600160a01b0316331461192e5760405162461bcd60e51b815260040161071790612cbc565b6001600160a01b03811661197d5760405162461bcd60e51b8152602060048201526016602482015275496e76616c69642057616c6c6574204164647265737360501b6044820152606401610717565b60a280546001600160a01b0383166001600160a01b031990911681179091556119ae6033546001600160a01b031690565b6001600160a01b03167fb150023a879fd806e3599b6ca8ee3b60f0e360ab3846d128d67ebce1a391639a60405160405180910390a350565b6119ee612842565b506001600160a01b03165f90815260a16020908152604091829020825161014081018452815481526001820154928101929092526002810154928201929092526003820154606082015260048201546080820152600582015460a0820152600682015460c0820152600782015460e0820152600882015461010082015260099091015460ff16151561012082015290565b600260655403611ad15760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610717565b6002606555565b6098545f90600160a01b900460ff161515600114611b2e5760405162461bcd60e51b81526020600482015260136024820152727761697420666f72207374617274206461746560681b6044820152606401610717565b335f90815260a1602052604090206009015460ff1615611cec5760a5544210611ce75760a554609955335f90815260a160205260408120600201548103611b93576099545f03611b7f575f91505090565b609954611b8c9042612d1c565b9050611bb2565b335f90815260a16020526040902060020154611baf9042612d1c565b90505b5f60a35482611bc19190612d78565b335f90815260a1602052604081206003015491925003611be3575f9250505090565b805f03611bf2575f9250505090565b335f90815260a160205260409020600301548110611c1e5750335f90815260a160205260409020600301545b335f90815260a16020526040812060040154611c3a9083612d2f565b335f90815260a160205260408120600381018054600590920154939450909291859190611c678386612d1c565b9091555050335f90815260a16020526040902060040154611c889085612d2f565b335f90815260a1602052604081206005018054909190611ca9908490612d1c565b9091555050335f90815260a1602052604090204260028201819055600690910155818403611cdd579450611eaf9350505050565b5090949350505050565b505f90565b60a954421115611e0457609854600160a81b900460ff161515600103611d6b57335f90815260a16020526040812060088101546005909101805491929091611d35908490612d1c565b9091555050335f90815260a16020526040902060098101805460ff19166001179055600881015442600690920191909155905090565b335f90815260a1602052604090206007810154600890910154611d8e9190612d46565b335f90815260a1602052604081206005018054909190611daf908490612d1c565b9091555050335f90815260a16020526040812060098101805460ff191660011790556007810154600890910154611de69190612d46565b335f90815260a160205260409020426006909101559150611eaf9050565b335f90815260a1602052604090206009015460ff1615611e2357505f90565b60a4544211611e3157505f90565b335f90815260a160205260408120600701549003611e4e57505f90565b6098805460ff60a81b1916600160a81b179055335f90815260a16020526040812060078101546005909101805491928392611e8a908490612d1c565b9091555050335f90815260a16020526040812060078101919091554260069091015590505b90565b6040516001600160a01b038316602482015260448101829052611f1590849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b031990931692909217909152612030565b505050565b6001606555565b5f54610100900460ff16611f475760405162461bcd60e51b815260040161071790612dab565b611f4f612101565b565b5f54610100900460ff16611f775760405162461bcd60e51b815260040161071790612dab565b611f4f612130565b5f80611f8a83612156565b9050611f9a8184608001516121e7565b9392505050565b6040516001600160a01b0380851660248301528316604482015260648101829052611fd99085906323b872dd60e01b90608401611ede565b50505050565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b5f612084826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166122099092919063ffffffff16565b805190915015611f1557808060200190518101906120a29190612d59565b611f155760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610717565b5f54610100900460ff166121275760405162461bcd60e51b815260040161071790612dab565b611f4f33611fdf565b5f54610100900460ff16611f1a5760405162461bcd60e51b815260040161071790612dab565b5f610c567fd50077d3975ee3e2d68b9f8110c90a67cd39e023247d3c8fc90d1e7eaa6a0e98835f01518460200151856040015186606001516040516020016121cc9594939291909485526001600160a01b0393841660208601529190921660408401526060830191909152608082015260a00190565b6040516020818303038152906040528051906020012061221f565b5f805f6121f4858561226b565b91509150612201816122d6565b509392505050565b606061221784845f8561248b565b949350505050565b5f610c5661222b612562565b8360405161190160f01b602082015260228101839052604281018290525f9060620160405160208183030381529060405280519060200120905092915050565b5f80825160410361229f576020830151604084015160608501515f1a61229387828585612688565b945094505050506122cf565b82516040036122c857602083015160408401516122bd86838361276d565b9350935050506122cf565b505f905060025b9250929050565b5f8160048111156122e9576122e9612df6565b036122f15750565b600181600481111561230557612305612df6565b036123525760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610717565b600281600481111561236657612366612df6565b036123b35760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610717565b60038160048111156123c7576123c7612df6565b0361241f5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610717565b600481600481111561243357612433612df6565b03610a3a5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202776272076616c604482015261756560f01b6064820152608401610717565b6060824710156124ec5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b6064820152608401610717565b5f80866001600160a01b031685876040516125079190612e0a565b5f6040518083038185875af1925050503d805f8114612541576040519150601f19603f3d011682016040523d82523d5f602084013e612546565b606091505b5091509150612557878383876127a5565b979650505050505050565b5f306001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161480156125ba57507f000000000000000000000000000000000000000000000000000000000000000046145b156125e457507f000000000000000000000000000000000000000000000000000000000000000090565b50604080517f00000000000000000000000000000000000000000000000000000000000000006020808301919091527f0000000000000000000000000000000000000000000000000000000000000000828401527f000000000000000000000000000000000000000000000000000000000000000060608301524660808301523060a0808401919091528351808403909101815260c0909201909252805191012090565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08311156126bd57505f90506003612764565b8460ff16601b141580156126d557508460ff16601c14155b156126e557505f90506004612764565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015612736573d5f803e3d5ffd5b5050604051601f1901519150506001600160a01b03811661275e575f60019250925050612764565b91505f90505b94509492505050565b5f806001600160ff1b0383168161278960ff86901c601b612d46565b905061279787828885612688565b935093505050935093915050565b606083156128135782515f0361280c576001600160a01b0385163b61280c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610717565b5081612217565b61221783838151156128285781518083602001fd5b8060405162461bcd60e51b81526004016107179190612e20565b6040518061014001604052805f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f81526020015f151581525090565b80356001600160a01b03811681146128a3575f80fd5b919050565b5f602082840312156128b8575f80fd5b611f9a8261288d565b634e487b7160e01b5f52604160045260245ffd5b60405160a0810167ffffffffffffffff811182821017156128f8576128f86128c1565b60405290565b6040805190810167ffffffffffffffff811182821017156128f8576128f86128c1565b604051601f8201601f1916810167ffffffffffffffff8111828210171561294a5761294a6128c1565b604052919050565b5f60a08284031215612962575f80fd5b61296a6128d5565b90506129758261288d565b8152602061298481840161288d565b818301526040830135604083015260608301356060830152608083013567ffffffffffffffff808211156129b6575f80fd5b818501915085601f8301126129c9575f80fd5b8135818111156129db576129db6128c1565b6129ed601f8201601f19168501612921565b91508082528684828501011115612a02575f80fd5b80848401858401375f8482840101525080608085015250505092915050565b5f60208284031215612a31575f80fd5b813567ffffffffffffffff811115612a47575f80fd5b61221784828501612952565b5f805f805f805f805f6101208a8c031215612a6c575f80fd5b612a758a61288d565b985060208a0135975060408a0135965060608a0135955060808a01359450612a9f60a08b0161288d565b935060c08a0135925060e08a013591506101008a013590509295985092959850929598565b5f805f60608486031215612ad6575f80fd5b612adf8461288d565b9250612aed6020850161288d565b9150604084013590509250925092565b5f60208284031215612b0d575f80fd5b5035919050565b5f6020808385031215612b25575f80fd5b823567ffffffffffffffff80821115612b3c575f80fd5b818501915085601f830112612b4f575f80fd5b813581811115612b6157612b616128c1565b612b6f848260051b01612921565b818152848101925060069190911b830184019087821115612b8e575f80fd5b928401925b818410156125575760408489031215612baa575f80fd5b612bb26128fe565b612bbb8561288d565b81528486013586820152835260409093019291840191612b93565b5f8060408385031215612be7575f80fd5b82359150602083013567ffffffffffffffff811115612c04575f80fd5b612c1085828601612952565b9150509250929050565b5f61014082019050825182526020830151602083015260408301516040830152606083015160608301526080830151608083015260a083015160a083015260c083015160c083015260e083015160e083015261010080840151818401525061012080840151612c8c8285018215159052565b505092915050565b5f8060408385031215612ca5575f80fd5b612cae8361288d565b946020939093013593505050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b5f60208284031215612d01575f80fd5b5051919050565b634e487b7160e01b5f52601160045260245ffd5b81810381811115610c5657610c56612d08565b8082028115828204841417610c5657610c56612d08565b80820180821115610c5657610c56612d08565b5f60208284031215612d69575f80fd5b81518015158114611f9a575f80fd5b5f82612d9257634e487b7160e01b5f52601260045260245ffd5b500490565b634e487b7160e01b5f52603260045260245ffd5b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b634e487b7160e01b5f52602160045260245ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122078b41bae2e6d411dea4c1ab6442cf3b3185183b0ebd0dd2ed33931230710b20d64736f6c63430008190033
Deployed Bytecode
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
Deployed Bytecode Sourcemap
45963:16562:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46586:51;;;;;;;;;;-1:-1:-1;46586:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;644:14:1;;637:22;619:41;;607:2;592:18;46586:51:0;;;;;;;;46344:35;;;;;;;;;;;;;;;;;;;817:25:1;;;805:2;790:18;46344:35:0;671:177:1;46535:44:0;;;;;;;;;;-1:-1:-1;46535:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;60588:204;;;;;;;;;;-1:-1:-1;60588:204:0;;;;;:::i;:::-;;:::i;:::-;;46157:21;;;;;;;;;;-1:-1:-1;46157:21:0;;;;-1:-1:-1;;;;;46157:21:0;;;;;;-1:-1:-1;;;;;1017:32:1;;;999:51;;987:2;972:18;46157:21:0;853:203:1;48003:121:0;;;;;;;;;;;;;:::i;47656:31::-;;;;;;;;;;;;;;;;51728:743;;;;;;;;;;-1:-1:-1;51728:743:0;;;;;:::i;:::-;;:::i;48224:127::-;;;;;;;;;;;;;:::i;46386:43::-;;;;;;;;;;;;;;;;60798:1062;;;;;;;;;;-1:-1:-1;60798:1062:0;;;;;:::i;:::-;;:::i;40978:118::-;;;;;;;;;;-1:-1:-1;40978:118:0;;;;;:::i;:::-;;:::i;57358:211::-;;;;;;;;;;-1:-1:-1;57358:211:0;;;;;:::i;:::-;;:::i;57192:160::-;;;;;;;;;;-1:-1:-1;57192:160:0;;;;;:::i;:::-;;:::i;48132:84::-;;;;;;;;;;-1:-1:-1;48132:84:0;;;;;:::i;:::-;;:::i;57575:2552::-;;;;;;;;;;-1:-1:-1;57575:2552:0;;;;;:::i;:::-;;:::i;:::-;;;;4869:25:1;;;4925:2;4910:18;;4903:34;;;;4953:18;;;4946:34;4857:2;4842:18;57575:2552:0;4667:319:1;62350:172:0;;;;;;;;;;;;;:::i;47502:26::-;;;;;;;;;;;;;;;;60168:333;;;;;;;;;;-1:-1:-1;60168:333:0;;;;;:::i;:::-;;:::i;51386:256::-;;;;;;;;;;-1:-1:-1;51386:256:0;;;;;:::i;:::-;;:::i;46436:29::-;;;;;;;;;;;;;;;;31919:87;;;;;;;;;;-1:-1:-1;31992:6:0;;-1:-1:-1;;;;;31992:6:0;31919:87;;47468:27;;;;;;;;;;;;;;;;47535:31;;;;;;;;;;;;;;;;46304:33;;;;;;;;;;;;;;;;46268:29;;;;;;;;;;;;;;;;47573:32;;;;;;;;;;;;;;;;50125:1199;;;;;;;;;;-1:-1:-1;50125:1199:0;;;;;:::i;:::-;;:::i;48864:1204::-;;;;;;;;;;-1:-1:-1;48864:1204:0;;;;;:::i;:::-;;:::i;62050:247::-;;;;;;;;;;-1:-1:-1;62050:247:0;;;;;:::i;:::-;;:::i;47612:37::-;;;;;;;;;;;;;;;;46644:52;;;;;;;;;;-1:-1:-1;46644:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6977:25:1;;;7033:2;7018:18;;7011:34;;;;7061:18;;;7054:34;;;;7119:2;7104:18;;7097:34;;;;7162:3;7147:19;;7140:35;;;;7206:3;7191:19;;7184:35;7250:3;7235:19;;7228:35;7294:3;7279:19;;7272:35;7338:3;7323:19;;7316:35;7395:14;7388:22;7382:3;7367:19;;7360:51;6964:3;6949:19;46644:52:0;6584:833:1;47866:129:0;;;;;;;;;;-1:-1:-1;47866:129:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;46474:54::-;;;;;;;;;;-1:-1:-1;46474:54:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;46120:30;;;;;;;;;;-1:-1:-1;46120:30:0;;;;-1:-1:-1;;;;;46120:30:0;;;60588:204;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;60660:20:0;::::1;60652:54;;;::::0;-1:-1:-1;;;60652:54:0;;9393:2:1;60652:54:0::1;::::0;::::1;9375:21:1::0;9432:2;9412:18;;;9405:30;-1:-1:-1;;;9451:18:1;;;9444:51;9512:18;;60652:54:0::1;9191:345:1::0;60652:54:0::1;60717:5;:33:::0;;-1:-1:-1;;;;;;60717:33:0::1;-1:-1:-1::0;;;;;60717:33:0;::::1;::::0;;::::1;::::0;;;60766:18:::1;::::0;999:51:1;;;60766:18:0::1;::::0;987:2:1;972:18;60766::0::1;;;;;;;;60588:204:::0;:::o;48003:121::-;48086:5;;:30;;-1:-1:-1;;;48086:30:0;;48110:4;48086:30;;;999:51:1;48059:7:0;;-1:-1:-1;;;;;48086:5:0;;:15;;972:18:1;;48086:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48079:37;;48003:121;:::o;51728:743::-;35312:21;:19;:21::i;:::-;51822:7:::1;:14:::0;;-1:-1:-1;;;;51822:14:0::1;-1:-1:-1::0;;;51822:14:0::1;::::0;;51898:12:::1;;51879:15;:31;;51871:67;;;::::0;-1:-1:-1;;;51871:67:0;;10280:2:1;51871:67:0::1;::::0;::::1;10262:21:1::0;10319:2;10299:18;;;10292:30;10358:25;10338:18;;;10331:53;10401:18;;51871:67:0::1;10078:347:1::0;51871:67:0::1;51968:10;51958:21;::::0;;;:9:::1;:21;::::0;;;;;;;51980:17:::1;::::0;::::1;::::0;51958:40;;;;;;;;::::1;;51957:41;51949:74;;;::::0;-1:-1:-1;;;51949:74:0;;10632:2:1;51949:74:0::1;::::0;::::1;10614:21:1::0;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:51;10751:18;;51949:74:0::1;10430:345:1::0;51949:74:0::1;52064:6;::::0;-1:-1:-1;;;;;52064:6:0::1;52042:18;52052:7:::0;52042:9:::1;:18::i;:::-;-1:-1:-1::0;;;;;52042:28:0::1;;52034:55;;;::::0;-1:-1:-1;;;52034:55:0;;10982:2:1;52034:55:0::1;::::0;::::1;10964:21:1::0;11021:2;11001:18;;;10994:30;-1:-1:-1;;;11040:18:1;;;11033:44;11094:18;;52034:55:0::1;10780:338:1::0;52034:55:0::1;52110:10;52100:21;::::0;;;:9:::1;:21;::::0;;;;;;;52122:17:::1;::::0;::::1;::::0;52100:40;;;;;;;:45;;-1:-1:-1;;52100:45:0::1;52141:4;52100:45:::0;;::::1;::::0;;;52141:4;52203:16:::1;:14;:16::i;:::-;52181:38:::0;-1:-1:-1;52181:38:0;52313:15;52305:47:::1;;;::::0;-1:-1:-1;;;52305:47:0;;9932:2:1;52305:47:0::1;::::0;::::1;9914:21:1::0;9971:2;9951:18;;;9944:30;-1:-1:-1;;;9990:18:1;;;9983:49;10049:18;;52305:47:0::1;9730:343:1::0;52305:47:0::1;52363:5;::::0;:43:::1;::::0;-1:-1:-1;;;;;52363:5:0::1;52382:10;52394:11:::0;52363:18:::1;:43::i;:::-;52422:41;::::0;;11297:25:1;;;11353:2;11338:18;;11331:34;;;52436:10:0::1;::::0;52422:41:::1;::::0;11270:18:1;52422:41:0::1;;;;;;;51803:668;;;35356:20:::0;34573:1;35876:7;:22;35693:213;35356:20;51728:743;:::o;48224:127::-;48275:7;48323:20;;48302:18;;:41;;;;:::i;60798:1062::-;27156:19;27179:13;;;;;;27178:14;;27226:34;;;;-1:-1:-1;27244:12:0;;27259:1;27244:12;;;;:16;27226:34;27225:108;;;-1:-1:-1;27305:4:0;15586:19;:23;;;27266:66;;-1:-1:-1;27315:12:0;;;;;:17;27266:66;27203:204;;;;-1:-1:-1;;;27203:204:0;;11843:2:1;27203:204:0;;;11825:21:1;11882:2;11862:18;;;11855:30;11921:34;11901:18;;;11894:62;-1:-1:-1;;;11972:18:1;;;11965:44;12026:19;;27203:204:0;11641:410:1;27203:204:0;27418:12;:16;;-1:-1:-1;;27418:16:0;27433:1;27418:16;;;27445:67;;;;27480:13;:20;;-1:-1:-1;;27480:20:0;;;;;27445:67;-1:-1:-1;;;;;61134:27:0;::::1;61126:36;;;::::0;::::1;;61173:10;:30:::0;;;61214:10:::1;:28:::0;;;61253:5:::1;:40:::0;;-1:-1:-1;;;;;;61253:40:0::1;-1:-1:-1::0;;;;;61253:40:0;::::1;;::::0;;61304:16:::1;:36:::0;;;61357:25:::1;:16:::0;61376:6:::1;61357:25;:::i;:::-;61351:3;:31:::0;61393:12:::1;:25:::0;;;61429:17:::1;:38:::0;;;61478:22:::1;:48:::0;;;61569:10:::1;::::0;:19:::1;::::0;61582:6:::1;61569:19;:::i;:::-;61556:32;::::0;:10;:32:::1;:::i;:::-;61537:16;:51:::0;61632:10:::1;::::0;:19:::1;::::0;61645:6:::1;61632:19;:::i;:::-;61613:16;;:38;;;;:::i;:::-;61599:11;:52:::0;61662:7:::1;:14:::0;;-1:-1:-1;;;;;61687:15:0;::::1;-1:-1:-1::0;;;;;;61687:15:0;;;;-1:-1:-1;;;61687:15:0;;;61745:36:::1;61765:16:::0;61745:17;:36:::1;:::i;:::-;:45;::::0;61784:6:::1;61745:45;:::i;:::-;61730:11;;:60;;;;:::i;:::-;61713:14;:77:::0;61801:16:::1;:14;:16::i;:::-;61828:24;:22;:24::i;:::-;27538:14:::0;27534:102;;;27585:5;27569:21;;-1:-1:-1;;27569:21:0;;;27610:14;;-1:-1:-1;12511:36:1;;27610:14:0;;12499:2:1;12484:18;27610:14:0;;;;;;;27534:102;27145:498;60798:1062;;;;;;;;;:::o;40978:118::-;41043:7;41070:18;41078:9;41070:7;:18::i;:::-;41063:25;40978:118;-1:-1:-1;;40978:118:0:o;57358:211::-;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;57461:56:::1;::::0;-1:-1:-1;;;57461:56:0;;-1:-1:-1;;;;;12750:32:1;;;57461:56:0::1;::::0;::::1;12732:51:1::0;12799:18;;;12792:34;;;57461::0;::::1;::::0;::::1;::::0;12705:18:1;;57461:56:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;57533:28:0::1;::::0;57554:6;;-1:-1:-1;;;;;57533:28:0;::::1;::::0;::::1;::::0;;;::::1;57358:211:::0;;;:::o;57192:160::-;57248:5;;:57;;-1:-1:-1;;;;;57248:5:0;57271:10;57291:4;57298:6;57248:22;:57::i;:::-;57338:6;57316:18;;:28;;;;;;;:::i;:::-;;;;-1:-1:-1;;;57192:160:0:o;48132:84::-;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;48194:6:::1;:14:::0;;-1:-1:-1;;;;;;48194:14:0::1;-1:-1:-1::0;;;;;48194:14:0;;;::::1;::::0;;;::::1;::::0;;48132:84::o;57575:2552::-;-1:-1:-1;;;;;57679:16:0;;57639:7;57679:16;;;:9;:16;;;;;:39;;;57639:7;;;;57679:39;;57675:2445;;;57760:11;;57741:15;:30;57737:1439;;57807:11;;57849:3;;-1:-1:-1;;;;;57908:16:0;;57788;57908;;;:9;:16;;;;;:31;;;:36;;57904:310;;57986:11;;58001:1;57986:16;57983:37;;58012:1;58015;58018;58004:16;;;;;;;;;;;57983:37;58056:30;58077:8;58057:15;58056:30;:::i;:::-;58039:47;;57904:310;;;-1:-1:-1;;;;;58166:16:0;;;;;;:9;:16;;;;;:31;;;58145:53;;58146:15;58145:53;:::i;:::-;58129:69;;57904:310;-1:-1:-1;;;;;58236:16:0;;;;;;:9;:16;;;;;:36;;;:41;;58232:119;;58306:1;58309;58312;58298:16;;;;;;;;;;;58232:119;58369:32;;58481:26;58501:5;58482:14;58481:26;:::i;:::-;-1:-1:-1;;;;;58568:16:0;;;;;;:9;:16;;;;;:36;;;58454:53;;-1:-1:-1;58540:64:0;;58536:168;;-1:-1:-1;;;;;58652:16:0;;;;;;:9;:16;;;;;:36;;;;-1:-1:-1;58536:168:0;-1:-1:-1;;;;;58763:16:0;;;;;;:9;:16;;;;;:30;;;58736:57;;:24;:57;:::i;:::-;-1:-1:-1;;;;;58832:16:0;;58808:21;58832:16;;;:9;:16;;;;;:36;;;;58903:31;;;;;58718:75;;-1:-1:-1;58832:36:0;58953:41;;;58949:154;;59021:7;-1:-1:-1;59030:1:0;;-1:-1:-1;59030:1:0;;-1:-1:-1;59013:22:0;;-1:-1:-1;;;;;;59013:22:0;58949:154;59063:15;;-1:-1:-1;59080:13:0;-1:-1:-1;59095:7:0;-1:-1:-1;59055:48:0;;-1:-1:-1;;;;59055:48:0;57737:1439;-1:-1:-1;59152:1:0;;-1:-1:-1;59152:1:0;;-1:-1:-1;59152:1:0;59144:16;;57675:2445;59232:16;;59214:15;:34;59210:899;;;59273:9;;-1:-1:-1;;;59273:9:0;;;;59269:498;;;-1:-1:-1;;;;;;;;59307:16:0;;;;;;:9;:16;;;;;59370:27;;;;59307:16;59362:42;;59269:498;59457:7;;-1:-1:-1;;;59457:7:0;;;;59453:29;;;-1:-1:-1;59474:1:0;;-1:-1:-1;59474:1:0;;-1:-1:-1;59474:1:0;59466:16;;59453:29;-1:-1:-1;;;;;59637:16:0;;;;;;:9;:16;;;;;:30;;;;59578:27;;;;;:89;;59637:30;59578:89;:::i;:::-;59695:1;59723;59543:204;;;;;;;;59210:899;59829:12;;59811:15;:30;59807:287;;;-1:-1:-1;59874:1:0;;-1:-1:-1;59874:1:0;;-1:-1:-1;59874:1:0;59866:16;;59807:287;-1:-1:-1;;;;;;;;59971:16:0;;;;;;:9;:16;;;;;60037:30;;;;59971:16;59807:287;57575:2552;;;;;:::o;62350:172::-;61927:12;;-1:-1:-1;;;;;61927:12:0;61913:10;:26;61905:70;;;;-1:-1:-1;;;61905:70:0;;13543:2:1;61905:70:0;;;13525:21:1;13582:2;13562:18;;;13555:30;13621:33;13601:18;;;13594:61;13672:18;;61905:70:0;13341:355:1;61905:70:0;62442:12:::1;::::0;62423:32:::1;::::0;-1:-1:-1;;;;;62442:12:0::1;62423:18;:32::i;:::-;62466:12;:25:::0;;-1:-1:-1;;;;;;62466:25:0::1;::::0;;62350:172::o;60168:333::-;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;60240:12:::1;:25:::0;;;60308:10:::1;::::0;:19:::1;::::0;60321:6:::1;60308:19;:::i;:::-;60295:32;::::0;:10;:32:::1;:::i;:::-;60276:16;:51:::0;60371:10:::1;::::0;:19:::1;::::0;60384:6:::1;60371:19;:::i;:::-;60352:16;;:38;;;;:::i;:::-;60338:11;:52:::0;60452:3:::1;::::0;60433:16:::1;::::0;:22:::1;::::0;60452:3;60433:22:::1;:::i;:::-;60418:11;;:37;;;;:::i;:::-;60401:14;:54:::0;60471:22:::1;::::0;817:25:1;;;60471:22:0::1;::::0;805:2:1;790:18;60471:22:0::1;671:177:1::0;51386:256:0;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51468:25:0;::::1;;::::0;;;:11:::1;:25;::::0;;;;;::::1;;51460:51;;;::::0;-1:-1:-1;;;51460:51:0;;13903:2:1;51460:51:0::1;::::0;::::1;13885:21:1::0;13942:2;13922:18;;;13915:30;-1:-1:-1;;;13961:18:1;;;13954:44;14015:18;;51460:51:0::1;13701:338:1::0;51460:51:0::1;-1:-1:-1::0;;;;;51529:23:0;::::1;;::::0;;;:9:::1;:23;::::0;;;;;;;51522:30;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;;::::0;;-1:-1:-1;;51522:30:0;;::::1;::::0;;;51563:11:::1;:25:::0;;;;;;:31;;;;::::1;::::0;;;51610:24;;999:51:1;;;51610:24:0::1;::::0;972:18:1;51610:24:0::1;853:203:1::0;50125:1199:0;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;35312:21:::1;:19;:21::i;:::-;50241:2:::2;50228:4;:11;:15;;50220:45;;;::::0;-1:-1:-1;;;50220:45:0;;14246:2:1;50220:45:0::2;::::0;::::2;14228:21:1::0;14285:2;14265:18;;;14258:30;-1:-1:-1;;;14304:18:1;;;14297:48;14362:18;;50220:45:0::2;14044:342:1::0;50220:45:0::2;50281:6;50276:1041;50296:4;:11;50292:1;:15;50276:1041;;;50338:11;:28;50350:4;50355:1;50350:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;50338:28:0::2;::::0;;;::::2;::::0;;;;;;50350:15:::2;50338:28:::0;;::::2;;50337:29;50328:60;;;::::0;-1:-1:-1;;;50328:60:0;;14725:2:1;50328:60:0::2;::::0;::::2;14707:21:1::0;14764:2;14744:18;;;14737:30;-1:-1:-1;;;14783:18:1;;;14776:48;14841:18;;50328:60:0::2;14523:342:1::0;50328:60:0::2;50434:4;50403:11;:28;50415:4;50420:1;50415:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;50403:28:0::2;::::0;;;::::2;::::0;;;;;;-1:-1:-1;50403:28:0;:35;;-1:-1:-1;;50403:35:0::2;::::0;::::2;;::::0;;;::::2;::::0;;50453:31:::2;;:::i;:::-;50523:4;50528:1;50523:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:14:::2;::::0;50499:38;;;50552:23:::2;::::0;::::2;:47:::0;;;50645:16:::2;::::0;50614:28:::2;::::0;::::2;:47:::0;50728:17:::2;::::0;50749:3:::2;::::0;50701:45:::2;::::0;50728:17;50701:45:::2;:::i;:::-;50700:52;;;;:::i;:::-;50676:22;::::0;::::2;:76:::0;50816:22:::2;::::0;50790:21;;50842:3:::2;::::0;50789:50:::2;::::0;::::2;:::i;:::-;50788:57;;;;:::i;:::-;50767:19;::::0;::::2;:78:::0;;;50963:16:::2;::::0;50913:22:::2;::::0;::::2;::::0;50887:21;;50963:16;;50767:78;50886:50:::2;::::0;50913:22;50886:50:::2;:::i;:::-;:74;;;;:::i;:::-;50885:94;;;;:::i;:::-;50860:22;::::0;::::2;:119:::0;50997:22:::2;::::0;::::2;::::0;:27;:55;::::2;;;-1:-1:-1::0;51028:19:0::2;::::0;::::2;::::0;:24;50997:55:::2;50994:132;;;51106:4;51072:31;::::0;::::2;:38:::0;50994:132:::2;51169:8;51140:9;:26;51150:4;51155:1;51150:7;;;;;;;;:::i;:::-;;::::0;;::::2;::::0;;;;;;;:15;-1:-1:-1;;;;;51140:26:0::2;::::0;;;;::::2;::::0;;;;;;;;-1:-1:-1;51140:26:0;;;:37;;;;;;::::2;::::0;::::2;::::0;::::2;::::0;;;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;::::2;::::0;;::::2;::::0;::::2;::::0;;::::2;::::0;;-1:-1:-1;;51140:37:0::2;::::0;::::2;;::::0;;;::::2;::::0;;51217:21;;51193:20:::2;:45:::0;;51217:21;;51193:20;;:45:::2;::::0;51217:21;;51193:45:::2;:::i;:::-;;;;;;;;51258:47;51274:4;51279:1;51274:7;;;;;;;;:::i;:::-;;;;;;;:15;;;51290:4;51295:1;51290:7;;;;;;;;:::i;:::-;;;;;;;:14;;;51258:47;;;;;;-1:-1:-1::0;;;;;12750:32:1;;;;12732:51;;12814:2;12799:18;;12792:34;12720:2;12705:18;;12558:274;51258:47:0::2;;;;;;;;-1:-1:-1::0;50308:3:0::2;;50276:1041;;;;35356:20:::1;34573:1:::0;35876:7;:22;35693:213;48864:1204;35312:21;:19;:21::i;:::-;48978:10:::1;48968:21;::::0;;;:9:::1;:21;::::0;;;;;;;48990:17:::1;::::0;::::1;::::0;48968:40;;;;;;;;::::1;;48967:41;48959:74;;;::::0;-1:-1:-1;;;48959:74:0;;10632:2:1;48959:74:0::1;::::0;::::1;10614:21:1::0;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:51;10751:18;;48959:74:0::1;10430:345:1::0;48959:74:0::1;49074:6;::::0;-1:-1:-1;;;;;49074:6:0::1;49052:18;49062:7:::0;49052:9:::1;:18::i;:::-;-1:-1:-1::0;;;;;49052:28:0::1;;49044:55;;;::::0;-1:-1:-1;;;49044:55:0;;10982:2:1;49044:55:0::1;::::0;::::1;10964:21:1::0;11021:2;11001:18;;;10994:30;-1:-1:-1;;;11040:18:1;;;11033:44;11094:18;;49044:55:0::1;10780:338:1::0;49044:55:0::1;49132:10;49120:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;49119:24;49110:55;;;::::0;-1:-1:-1;;;49110:55:0;;14725:2:1;49110:55:0::1;::::0;::::1;14707:21:1::0;14764:2;14744:18;;;14737:30;-1:-1:-1;;;14783:18:1;;;14776:48;14841:18;;49110:55:0::1;14523:342:1::0;49110:55:0::1;49186:10;49176:21;::::0;;;:9:::1;:21;::::0;;;;;;;49198:17:::1;::::0;::::1;::::0;49176:40;;;;;;;:45;;49217:4:::1;-1:-1:-1::0;;49176:45:0;;::::1;::::0;::::1;::::0;;;49232:23;;;:11:::1;:23:::0;;;;;;:30;;;;::::1;;::::0;;49273:31:::1;;:::i;:::-;49315:30:::0;;;49356:23:::1;::::0;::::1;:47:::0;;;49445:16:::1;::::0;49414:28:::1;::::0;::::1;:47:::0;49524:17:::1;::::0;49545:3:::1;::::0;49497:45:::1;::::0;49339:6;49497:45:::1;:::i;:::-;49496:52;;;;:::i;:::-;49472:22;::::0;::::1;:76:::0;49608:22:::1;::::0;49582:21;;49634:3:::1;::::0;49581:50:::1;::::0;::::1;:::i;:::-;49580:57;;;;:::i;:::-;49559:19;::::0;::::1;:78:::0;;;49751:16:::1;::::0;49701:22:::1;::::0;::::1;::::0;49675:21;;49751:16;;49559:78;49674:50:::1;::::0;49701:22;49674:50:::1;:::i;:::-;:74;;;;:::i;:::-;49673:94;;;;:::i;:::-;49648:22;::::0;::::1;:119:::0;49781:22:::1;::::0;::::1;::::0;:27;:55;::::1;;;-1:-1:-1::0;49812:19:0::1;::::0;::::1;::::0;:24;49781:55:::1;49778:124;;;49886:4;49852:31;::::0;::::1;:38:::0;49778:124:::1;49922:19:::0;;-1:-1:-1;;;;;49912:30:0::1;;::::0;;;:9:::1;:30;::::0;;;;;;;:41;;;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;;-1:-1:-1;;49912:41:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49965:20:::1;:45:::0;;49912:41;;49965:20;;:45:::1;::::0;49912:41;;49965:45:::1;:::i;:::-;::::0;;;-1:-1:-1;;50026:34:0::1;::::0;;50042:10:::1;12732:51:1::0;;12814:2;12799:18;;12792:34;;;50026::0::1;::::0;12705:18:1;50026:34:0::1;;;;;;;48948:1120;35356:20:::0;34573:1;35876:7;:22;35693:213;35356:20;48864:1204;;:::o;62050:247::-;31992:6;;-1:-1:-1;;;;;31992:6:0;30887:10;32139:23;32131:68;;;;-1:-1:-1;;;32131:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;62141:22:0;::::1;62133:57;;;::::0;-1:-1:-1;;;62133:57:0;;15072:2:1;62133:57:0::1;::::0;::::1;15054:21:1::0;15111:2;15091:18;;;15084:30;-1:-1:-1;;;15130:18:1;;;15123:52;15192:18;;62133:57:0::1;14870:346:1::0;62133:57:0::1;62201:12;:23:::0;;-1:-1:-1;;;;;62201:23:0;::::1;-1:-1:-1::0;;;;;;62201:23:0;;::::1;::::0;::::1;::::0;;;62267:7:::1;31992:6:::0;;-1:-1:-1;;;;;31992:6:0;;31919:87;62267:7:::1;-1:-1:-1::0;;;;;62240:49:0::1;;;;;;;;;;;62050:247:::0;:::o;47866:129::-;47929:22;;:::i;:::-;-1:-1:-1;;;;;;47971:16:0;;;;;:9;:16;;;;;;;;;47964:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47866:129::o;35392:293::-;34617:1;35526:7;;:19;35518:63;;;;-1:-1:-1;;;35518:63:0;;15423:2:1;35518:63:0;;;15405:21:1;15462:2;15442:18;;;15435:30;15501:33;15481:18;;;15474:61;15552:18;;35518:63:0;15221:355:1;35518:63:0;34617:1;35659:7;:18;35392:293::o;52477:4631::-;47230:7;;52529;;-1:-1:-1;;;47230:7:0;;;;:15;;47241:4;47230:15;47222:47;;;;-1:-1:-1;;;47222:47:0;;9932:2:1;47222:47:0;;;9914:21:1;9971:2;9951:18;;;9944:30;-1:-1:-1;;;9990:18:1;;;9983:49;10049:18;;47222:47:0;9730:343:1;47222:47:0;52565:10:::1;52555:21;::::0;;;:9:::1;:21;::::0;;;;:44:::1;;::::0;::::1;;52551:4550;;;52639:11;;52620:15;:30;52616:2532;;52688:11;::::0;52671:14:::1;:28:::0;52874:10:::1;-1:-1:-1::0;52864:21:0;;;:9:::1;:21;::::0;;;;:36:::1;;::::0;:41;;52860:447:::1;;52936:14;;52954:1;52936:19:::0;52932:112:::1;;52991:1;52984:8;;;52477:4631:::0;:::o;52932:112::-:1;53103:14;::::0;53085:32:::1;::::0;:15:::1;:32;:::i;:::-;53068:49;;52860:447;;;53261:10;53251:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;::::0;53208:79:::1;::::0;:15:::1;:79;:::i;:::-;53166:121;;52860:447;53327:32;53379:3;;53362:14;:20;;;;:::i;:::-;53489:10;53479:21;::::0;;;:9:::1;:21;::::0;;;;:41:::1;;::::0;53327:55;;-1:-1:-1;53479:46:0;53475:124:::1;;53557:1;53550:8;;;;52477:4631:::0;:::o;53475:124::-:1;53698:24;53726:1;53698:29:::0;53694:127:::1;;53759:1;53752:8;;;;52477:4631:::0;:::o;53694:127::-:1;53926:10;53916:21;::::0;;;:9:::1;:21;::::0;;;;:41:::1;;::::0;53867:90;::::1;53841:273;;-1:-1:-1::0;54037:10:0::1;54027:21;::::0;;;:9:::1;:21;::::0;;;;:67:::1;;::::0;53841:273:::1;54218:10;54134:23;54208:21:::0;;;:9:::1;:21;::::0;;;;:35:::1;;::::0;54160:83:::1;::::0;:24;:83:::1;:::i;:::-;54299:10;54264:22;54289:21:::0;;;:9:::1;:21;::::0;;;;:63:::1;::::0;::::1;::::0;;54389:36:::1;::::0;;::::1;::::0;54134:109;;-1:-1:-1;54289:63:0;;54389:36;54511:24;;54289:63;54444:91:::1;54511:24:::0;54289:63;54444:91:::1;:::i;:::-;::::0;;;-1:-1:-1;;54673:10:0::1;54663:21;::::0;;;:9:::1;:21;::::0;;;;:35:::1;;::::0;54615:83:::1;::::0;:24;:83:::1;:::i;:::-;54564:10;54554:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;:144:::0;;:36;;:21;:144:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;54727:10:0::1;54717:21;::::0;;;:9:::1;:21;::::0;;;;54756:15:::1;54717:36;::::0;::::1;:54:::0;;;54790:45:::1;::::0;;::::1;:63:::0;54876:42;;;54872:176:::1;;54950:7:::0;-1:-1:-1;54943:14:0::1;::::0;-1:-1:-1;;;;54943:14:0::1;54872:176;-1:-1:-1::0;55013:15:0;;52477:4631;-1:-1:-1;;;;52477:4631:0:o;52616:2532::-:1;-1:-1:-1::0;55095:1:0::1;52477:4631:::0;:::o;52551:4550::-:1;55202:16;;55184:15;:34;55180:1910;;;55243:9;::::0;-1:-1:-1;;;55243:9:0;::::1;;;:17;;55256:4;55243:17:::0;55239:994:::1;;55361:10;55325:69;::::0;;;:9:::1;:69;::::0;;;;:80:::1;::::0;::::1;::::0;55285:36:::1;::::0;;::::1;:120:::0;;55325:80;;55285:36;;:120:::1;::::0;55325:80;;55285:120:::1;:::i;:::-;::::0;;;-1:-1:-1;;55438:10:0::1;55428:21;::::0;;;:9:::1;:21;::::0;;;;:44:::1;::::0;::::1;:51:::0;;-1:-1:-1;;55428:51:0::1;55475:4;55428:51;::::0;;55519:32:::1;::::0;::::1;::::0;55622:15:::1;55574:45;::::0;;::::1;:63:::0;;;;55519:32;-1:-1:-1;52477:4631:0;:::o;55239:994::-:1;55857:10;55847:21;::::0;;;:9:::1;:21;::::0;;;;:35:::1;::::0;::::1;::::0;55787:32:::1;::::0;;::::1;::::0;:95:::1;::::0;55847:35;55787:95:::1;:::i;:::-;55732:10;55722:21;::::0;;;:9:::1;:21;::::0;;;;:36:::1;;:160:::0;;:36;;:21;:160:::1;::::0;;;::::1;:::i;:::-;::::0;;;-1:-1:-1;;55915:10:0::1;55905:21;::::0;;;:9:::1;:21;::::0;;;;:44:::1;::::0;::::1;:51:::0;;-1:-1:-1;;55905:51:0::1;55952:4;55905:51;::::0;;56056:35:::1;::::0;::::1;::::0;55996:32:::1;::::0;;::::1;::::0;:95:::1;::::0;56056:35;55996:95:::1;:::i;:::-;56124:10;56114:21;::::0;;;:9:::1;:21;::::0;;;;56162:15:::1;56114:45;::::0;;::::1;:63:::0;55979:112;-1:-1:-1;56200:13:0::1;::::0;-1:-1:-1;56200:13:0::1;55180:1910;56287:10;56277:21;::::0;;;:9:::1;:21;::::0;;;;:44:::1;;::::0;::::1;;56273:129;;;-1:-1:-1::0;56353:1:0::1;52477:4631:::0;:::o;56273:129::-:1;56443:12;;56424:15;:31;56420:117;;-1:-1:-1::0;56487:1:0::1;52477:4631:::0;:::o;56420:117::-:1;56569:10;56559:21;::::0;;;:9:::1;:21;::::0;;;;:35:::1;;::::0;:40;;56555:124:::1;;-1:-1:-1::0;56631:1:0::1;52477:4631:::0;:::o;56555:124::-:1;56699:9;:16:::0;;-1:-1:-1;;;;56699:16:0::1;-1:-1:-1::0;;;56699:16:0::1;::::0;;56761:10:::1;56699:16:::0;56751:21;;;:9:::1;:21;::::0;;;;:35:::1;::::0;::::1;::::0;56805:36:::1;::::0;;::::1;:97:::0;;56751:35;;;;56805:97:::1;::::0;56751:35;;56805:97:::1;:::i;:::-;::::0;;;-1:-1:-1;;56931:10:0::1;56959:1;56921:21:::0;;;:9:::1;:21;::::0;;;;:35:::1;::::0;::::1;:39:::0;;;;57027:15:::1;56979:45;::::0;;::::1;:63:::0;57068:6;-1:-1:-1;55180:1910:0::1;52477:4631:::0;:::o;42098:222::-;42253:58;;-1:-1:-1;;;;;12750:32:1;;42253:58:0;;;12732:51:1;12799:18;;;12792:34;;;42226:86:0;;42246:5;;-1:-1:-1;;;42276:23:0;12705:18:1;;42253:58:0;;;;-1:-1:-1;;42253:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;42253:58:0;-1:-1:-1;;;;;;42253:58:0;;;;;;;;;;42226:19;:86::i;:::-;42098:222;;;:::o;35693:213::-;34573:1;35876:7;:22;35693:213::o;31620:97::-;29299:13;;;;;;;29291:69;;;;-1:-1:-1;;;29291:69:0;;;;;;;:::i;:::-;31683:26:::1;:24;:26::i;:::-;31620:97::o:0;34659:113::-;29299:13;;;;;;;29291:69;;;;-1:-1:-1;;;29291:69:0;;;;;;;:::i;:::-;34730:34:::1;:32;:34::i;41824:186::-:0;41889:7;41909:14;41926:16;41932:9;41926:5;:16::i;:::-;41909:33;;41960:42;41974:6;41982:9;:19;;;41960:13;:42::i;:::-;41953:49;41824:186;-1:-1:-1;;;41824:186:0:o;42328:259::-;42510:68;;-1:-1:-1;;;;;16251:15:1;;;42510:68:0;;;16233:34:1;16303:15;;16283:18;;;16276:43;16335:18;;;16328:34;;;42483:96:0;;42503:5;;-1:-1:-1;;;42533:27:0;16168:18:1;;42510:68:0;15993:375:1;42483:96:0;42328:259;;;;:::o;33211:191::-;33304:6;;;-1:-1:-1;;;;;33321:17:0;;;-1:-1:-1;;;;;;33321:17:0;;;;;;;33354:40;;33304:6;;;33321:17;33304:6;;33354:40;;33285:16;;33354:40;33274:128;33211:191;:::o;45231:727::-;45666:23;45692:69;45720:4;45692:69;;;;;;;;;;;;;;;;;45700:5;-1:-1:-1;;;;;45692:27:0;;;:69;;;;;:::i;:::-;45776:17;;45666:95;;-1:-1:-1;45776:21:0;45772:179;;45873:10;45862:30;;;;;;;;;;;;:::i;:::-;45854:85;;;;-1:-1:-1;;;45854:85:0;;16575:2:1;45854:85:0;;;16557:21:1;16614:2;16594:18;;;16587:30;16653:34;16633:18;;;16626:62;-1:-1:-1;;;16704:18:1;;;16697:40;16754:19;;45854:85:0;16373:406:1;31725:113:0;29299:13;;;;;;;29291:69;;;;-1:-1:-1;;;29291:69:0;;;;;;;:::i;:::-;31798:32:::1;30887:10:::0;31798:18:::1;:32::i;34780:111::-:0;29299:13;;;;;;;29291:69;;;;-1:-1:-1;;;29291:69:0;;;;;;;:::i;41210:606::-;41273:7;41313:495;41417:149;41593:9;:21;;;41641:9;:25;;;41693:9;:12;;;41732:9;:19;;;41380:394;;;;;;;;;;;17043:25:1;;;-1:-1:-1;;;;;17142:15:1;;;17137:2;17122:18;;17115:43;17194:15;;;;17189:2;17174:18;;17167:43;17241:2;17226:18;;17219:34;;;;17284:3;17269:19;;17262:35;17030:3;17015:19;;16784:519;41380:394:0;;;;;;;;;;;;;41348:445;;;;;;41313:16;:495::i;8732:263::-;8837:7;8863:17;8882:18;8904:27;8915:4;8921:9;8904:10;:27::i;:::-;8862:69;;;;8942:18;8954:5;8942:11;:18::i;:::-;-1:-1:-1;8978:9:0;8732:263;-1:-1:-1;;;8732:263:0:o;18048:229::-;18185:12;18217:52;18239:6;18247:4;18253:1;18256:12;18217:21;:52::i;:::-;18210:59;18048:229;-1:-1:-1;;;;18048:229:0:o;26031:208::-;26144:7;26176:55;26198:20;:18;:20::i;:::-;26220:10;14187:57;;-1:-1:-1;;;14187:57:0;;;19930:27:1;19973:11;;;19966:27;;;20009:12;;;20002:28;;;14114:7:0;;20046:12:1;;14187:57:0;;;;;;;;;;;;14159:100;;;;;;14139:120;;13994:273;;;;;6590:1340;6698:7;6707:12;6937:9;:16;6957:2;6937:22;6933:990;;7233:4;7218:20;;7212:27;7283:4;7268:20;;7262:27;7341:4;7326:20;;7320:27;6976:9;7312:36;7384:25;7395:4;7312:36;7212:27;7262;7384:10;:25::i;:::-;7377:32;;;;;;;;;6933:990;7431:9;:16;7451:2;7431:22;7427:496;;7706:4;7691:20;;7685:27;7757:4;7742:20;;7736:27;7799:23;7810:4;7685:27;7736;7799:10;:23::i;:::-;7792:30;;;;;;;;7427:496;-1:-1:-1;7871:1:0;;-1:-1:-1;7875:35:0;7427:496;6590:1340;;;;;:::o;4861:643::-;4939:20;4930:5;:29;;;;;;;;:::i;:::-;;4926:571;;4861:643;:::o;4926:571::-;5037:29;5028:5;:38;;;;;;;;:::i;:::-;;5024:473;;5083:34;;-1:-1:-1;;;5083:34:0;;17642:2:1;5083:34:0;;;17624:21:1;17681:2;17661:18;;;17654:30;17720:26;17700:18;;;17693:54;17764:18;;5083:34:0;17440:348:1;5024:473:0;5148:35;5139:5;:44;;;;;;;;:::i;:::-;;5135:362;;5200:41;;-1:-1:-1;;;5200:41:0;;17995:2:1;5200:41:0;;;17977:21:1;18034:2;18014:18;;;18007:30;18073:33;18053:18;;;18046:61;18124:18;;5200:41:0;17793:355:1;5135:362:0;5272:30;5263:5;:39;;;;;;;;:::i;:::-;;5259:238;;5319:44;;-1:-1:-1;;;5319:44:0;;18355:2:1;5319:44:0;;;18337:21:1;18394:2;18374:18;;;18367:30;18433:34;18413:18;;;18406:62;-1:-1:-1;;;18484:18:1;;;18477:32;18526:19;;5319:44:0;18153:398:1;5259:238:0;5394:30;5385:5;:39;;;;;;;;:::i;:::-;;5381:116;;5441:44;;-1:-1:-1;;;5441:44:0;;18758:2:1;5441:44:0;;;18740:21:1;18797:2;18777:18;;;18770:30;18836:34;18816:18;;;18809:62;-1:-1:-1;;;18887:18:1;;;18880:32;18929:19;;5441:44:0;18556:398:1;19168:455:0;19338:12;19396:5;19371:21;:30;;19363:81;;;;-1:-1:-1;;;19363:81:0;;19161:2:1;19363:81:0;;;19143:21:1;19200:2;19180:18;;;19173:30;19239:34;19219:18;;;19212:62;-1:-1:-1;;;19290:18:1;;;19283:36;19336:19;;19363:81:0;18959:402:1;19363:81:0;19456:12;19470:23;19497:6;-1:-1:-1;;;;;19497:11:0;19516:5;19523:4;19497:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19455:73;;;;19546:69;19573:6;19581:7;19590:10;19602:12;19546:26;:69::i;:::-;19539:76;19168:455;-1:-1:-1;;;;;;;19168:455:0:o;24512:437::-;24565:7;24611:4;-1:-1:-1;;;;;24620:12:0;24603:29;;:66;;;;;24653:16;24636:13;:33;24603:66;24585:357;;;-1:-1:-1;24703:24:0;;24512:437::o;24585:357::-;-1:-1:-1;25169:197:0;;;24828:10;25169:197;;;;21089:25:1;;;;24861:12:0;21130:18:1;;;21123:34;24896:15:0;21173:18:1;;;21166:34;25298:13:0;21216:18:1;;;21209:34;25342:4:0;21259:19:1;;;;21252:61;;;;25169:197:0;;;;;;;;;;21061:19:1;;;;25169:197:0;;;25141:240;;;;;;48003:121::o;10261:1669::-;10392:7;;11353:66;11327:92;;11309:200;;;-1:-1:-1;11462:1:0;;-1:-1:-1;11466:30:0;11446:51;;11309:200;11523:1;:7;;11528:2;11523:7;;:18;;;;;11534:1;:7;;11539:2;11534:7;;11523:18;11519:102;;;-1:-1:-1;11574:1:0;;-1:-1:-1;11578:30:0;11558:51;;11519:102;11735:24;;;11718:14;11735:24;;;;;;;;;20296:25:1;;;20369:4;20357:17;;20337:18;;;20330:45;;;;20391:18;;;20384:34;;;20434:18;;;20427:34;;;11735:24:0;;20268:19:1;;11735:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11735:24:0;;-1:-1:-1;;11735:24:0;;;-1:-1:-1;;;;;;;11774:20:0;;11770:103;;11827:1;11831:29;11811:50;;;;;;;11770:103;11893:6;-1:-1:-1;11901:20:0;;-1:-1:-1;10261:1669:0;;;;;;;;:::o;9258:389::-;9372:7;;-1:-1:-1;;;;;9418:125:0;;9372:7;9570:25;9586:3;9571:18;;;9593:2;9570:25;:::i;:::-;9554:42;;9614:25;9625:4;9631:1;9634;9637;9614:10;:25::i;:::-;9607:32;;;;;;9258:389;;;;;;:::o;20828:644::-;21013:12;21042:7;21038:427;;;21070:10;:17;21091:1;21070:22;21066:290;;-1:-1:-1;;;;;15586:19:0;;;21280:60;;;;-1:-1:-1;;;21280:60:0;;20674:2:1;21280:60:0;;;20656:21:1;20713:2;20693:18;;;20686:30;20752:31;20732:18;;;20725:59;20801:18;;21280:60:0;20472:353:1;21280:60:0;-1:-1:-1;21377:10:0;21370:17;;21038:427;21420:33;21428:10;21440:12;22175:17;;:21;22171:388;;22407:10;22401:17;22464:15;22451:10;22447:2;22443:19;22436:44;22171:388;22534:12;22527:20;;-1:-1:-1;;;22527:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;1061:127::-;1122:10;1117:3;1113:20;1110:1;1103:31;1153:4;1150:1;1143:15;1177:4;1174:1;1167:15;1193:253;1265:2;1259:9;1307:4;1295:17;;1342:18;1327:34;;1363:22;;;1324:62;1321:88;;;1389:18;;:::i;:::-;1425:2;1418:22;1193:253;:::o;1451:257::-;1523:4;1517:11;;;1555:17;;1602:18;1587:34;;1623:22;;;1584:62;1581:88;;;1649:18;;:::i;1713:275::-;1784:2;1778:9;1849:2;1830:13;;-1:-1:-1;;1826:27:1;1814:40;;1884:18;1869:34;;1905:22;;;1866:62;1863:88;;;1931:18;;:::i;:::-;1967:2;1960:22;1713:275;;-1:-1:-1;1713:275:1:o;1993:1056::-;2046:5;2094:4;2082:9;2077:3;2073:19;2069:30;2066:50;;;2112:1;2109;2102:12;2066:50;2134:22;;:::i;:::-;2125:31;;2179:29;2198:9;2179:29;:::i;:::-;2172:5;2165:44;2228:2;2262:38;2296:2;2285:9;2281:18;2262:38;:::i;:::-;2257:2;2250:5;2246:14;2239:62;2361:2;2350:9;2346:18;2333:32;2328:2;2321:5;2317:14;2310:56;2426:2;2415:9;2411:18;2398:32;2393:2;2386:5;2382:14;2375:56;2482:3;2471:9;2467:19;2454:33;2506:18;2547:2;2539:6;2536:14;2533:34;;;2563:1;2560;2553:12;2533:34;2601:6;2590:9;2586:22;2576:32;;2646:3;2639:4;2635:2;2631:13;2627:23;2617:51;;2664:1;2661;2654:12;2617:51;2700:2;2687:16;2722:2;2718;2715:10;2712:36;;;2728:18;;:::i;:::-;2770:53;2813:2;2794:13;;-1:-1:-1;;2790:27:1;2786:36;;2770:53;:::i;:::-;2757:66;;2846:2;2839:5;2832:17;2886:3;2881:2;2876;2872;2868:11;2864:20;2861:29;2858:49;;;2903:1;2900;2893:12;2858:49;2958:2;2953;2949;2945:11;2940:2;2933:5;2929:14;2916:45;3002:1;2997:2;2992;2985:5;2981:14;2977:23;2970:34;;3037:5;3031:3;3024:5;3020:15;3013:30;;;;1993:1056;;;;:::o;3054:343::-;3137:6;3190:2;3178:9;3169:7;3165:23;3161:32;3158:52;;;3206:1;3203;3196:12;3158:52;3246:9;3233:23;3279:18;3271:6;3268:30;3265:50;;;3311:1;3308;3301:12;3265:50;3334:57;3383:7;3374:6;3363:9;3359:22;3334:57;:::i;3402:742::-;3533:6;3541;3549;3557;3565;3573;3581;3589;3597;3650:3;3638:9;3629:7;3625:23;3621:33;3618:53;;;3667:1;3664;3657:12;3618:53;3690:29;3709:9;3690:29;:::i;:::-;3680:39;;3766:2;3755:9;3751:18;3738:32;3728:42;;3817:2;3806:9;3802:18;3789:32;3779:42;;3868:2;3857:9;3853:18;3840:32;3830:42;;3919:3;3908:9;3904:19;3891:33;3881:43;;3943:39;3977:3;3966:9;3962:19;3943:39;:::i;:::-;3933:49;;4029:3;4018:9;4014:19;4001:33;3991:43;;4081:3;4070:9;4066:19;4053:33;4043:43;;4133:3;4122:9;4118:19;4105:33;4095:43;;3402:742;;;;;;;;;;;:::o;4149:328::-;4226:6;4234;4242;4295:2;4283:9;4274:7;4270:23;4266:32;4263:52;;;4311:1;4308;4301:12;4263:52;4334:29;4353:9;4334:29;:::i;:::-;4324:39;;4382:38;4416:2;4405:9;4401:18;4382:38;:::i;:::-;4372:48;;4467:2;4456:9;4452:18;4439:32;4429:42;;4149:328;;;;;:::o;4482:180::-;4541:6;4594:2;4582:9;4573:7;4569:23;4565:32;4562:52;;;4610:1;4607;4600:12;4562:52;-1:-1:-1;4633:23:1;;4482:180;-1:-1:-1;4482:180:1:o;4991:1172::-;5101:6;5132:2;5175;5163:9;5154:7;5150:23;5146:32;5143:52;;;5191:1;5188;5181:12;5143:52;5231:9;5218:23;5260:18;5301:2;5293:6;5290:14;5287:34;;;5317:1;5314;5307:12;5287:34;5355:6;5344:9;5340:22;5330:32;;5400:7;5393:4;5389:2;5385:13;5381:27;5371:55;;5422:1;5419;5412:12;5371:55;5458:2;5445:16;5480:2;5476;5473:10;5470:36;;;5486:18;;:::i;:::-;5526:36;5558:2;5553;5550:1;5546:10;5542:19;5526:36;:::i;:::-;5596:15;;;5627:12;;;;-1:-1:-1;5678:1:1;5674:10;;;;5666:19;;5662:28;;;5702:19;;;5699:39;;;5734:1;5731;5724:12;5699:39;5758:11;;;;5778:355;5794:6;5789:3;5786:15;5778:355;;;5876:4;5870:3;5861:7;5857:17;5853:28;5850:48;;;5894:1;5891;5884:12;5850:48;5924:22;;:::i;:::-;5973:23;5992:3;5973:23;:::i;:::-;5959:38;;6046:12;;;6033:26;6017:14;;;6010:50;6073:18;;5820:4;5811:14;;;;6111:12;;;;5778:355;;6168:411;6260:6;6268;6321:2;6309:9;6300:7;6296:23;6292:32;6289:52;;;6337:1;6334;6327:12;6289:52;6373:9;6360:23;6350:33;;6434:2;6423:9;6419:18;6406:32;6461:18;6453:6;6450:30;6447:50;;;6493:1;6490;6483:12;6447:50;6516:57;6565:7;6556:6;6545:9;6541:22;6516:57;:::i;:::-;6506:67;;;6168:411;;;;;:::o;7422:910::-;7580:4;7622:3;7611:9;7607:19;7599:27;;7659:6;7653:13;7642:9;7635:32;7723:4;7715:6;7711:17;7705:24;7698:4;7687:9;7683:20;7676:54;7786:4;7778:6;7774:17;7768:24;7761:4;7750:9;7746:20;7739:54;7849:4;7841:6;7837:17;7831:24;7824:4;7813:9;7809:20;7802:54;7912:4;7904:6;7900:17;7894:24;7887:4;7876:9;7872:20;7865:54;7975:4;7967:6;7963:17;7957:24;7950:4;7939:9;7935:20;7928:54;8038:4;8030:6;8026:17;8020:24;8013:4;8002:9;7998:20;7991:54;8101:4;8093:6;8089:17;8083:24;8076:4;8065:9;8061:20;8054:54;8127:6;8187:2;8179:6;8175:15;8169:22;8164:2;8153:9;8149:18;8142:50;;8211:6;8264:2;8256:6;8252:15;8246:22;8277:49;8322:2;8311:9;8307:18;8293:12;453:13;446:21;434:34;;383:91;8277:49;;;7422:910;;;;:::o;8337:254::-;8405:6;8413;8466:2;8454:9;8445:7;8441:23;8437:32;8434:52;;;8482:1;8479;8472:12;8434:52;8505:29;8524:9;8505:29;:::i;:::-;8495:39;8581:2;8566:18;;;;8553:32;;-1:-1:-1;;;8337:254:1:o;8830:356::-;9032:2;9014:21;;;9051:18;;;9044:30;9110:34;9105:2;9090:18;;9083:62;9177:2;9162:18;;8830:356::o;9541:184::-;9611:6;9664:2;9652:9;9643:7;9639:23;9635:32;9632:52;;;9680:1;9677;9670:12;9632:52;-1:-1:-1;9703:16:1;;9541:184;-1:-1:-1;9541:184:1:o;11376:127::-;11437:10;11432:3;11428:20;11425:1;11418:31;11468:4;11465:1;11458:15;11492:4;11489:1;11482:15;11508:128;11575:9;;;11596:11;;;11593:37;;;11610:18;;:::i;12056:168::-;12129:9;;;12160;;12177:15;;;12171:22;;12157:37;12147:71;;12198:18;;:::i;12229:125::-;12294:9;;;12315:10;;;12312:36;;;12328:18;;:::i;12837:277::-;12904:6;12957:2;12945:9;12936:7;12932:23;12928:32;12925:52;;;12973:1;12970;12963:12;12925:52;13005:9;12999:16;13058:5;13051:13;13044:21;13037:5;13034:32;13024:60;;13080:1;13077;13070:12;13119:217;13159:1;13185;13175:132;;13229:10;13224:3;13220:20;13217:1;13210:31;13264:4;13261:1;13254:15;13292:4;13289:1;13282:15;13175:132;-1:-1:-1;13321:9:1;;13119:217::o;14391:127::-;14452:10;14447:3;14443:20;14440:1;14433:31;14483:4;14480:1;14473:15;14507:4;14504:1;14497:15;15581:407;15783:2;15765:21;;;15822:2;15802:18;;;15795:30;15861:34;15856:2;15841:18;;15834:62;-1:-1:-1;;;15927:2:1;15912:18;;15905:41;15978:3;15963:19;;15581:407::o;17308:127::-;17369:10;17364:3;17360:20;17357:1;17350:31;17400:4;17397:1;17390:15;17424:4;17421:1;17414:15;19366:301;19495:3;19533:6;19527:13;19579:6;19572:4;19564:6;19560:17;19555:3;19549:37;19641:1;19605:16;;19630:13;;;-1:-1:-1;19605:16:1;19366:301;-1:-1:-1;19366:301:1:o;21324:418::-;21473:2;21462:9;21455:21;21436:4;21505:6;21499:13;21548:6;21543:2;21532:9;21528:18;21521:34;21607:6;21602:2;21594:6;21590:15;21585:2;21574:9;21570:18;21564:50;21663:1;21658:2;21649:6;21638:9;21634:22;21630:31;21623:42;21733:2;21726;21722:7;21717:2;21709:6;21705:15;21701:29;21690:9;21686:45;21682:54;21674:62;;;21324:418;;;;:::o
Swarm Source
ipfs://78b41bae2e6d411dea4c1ab6442cf3b3185183b0ebd0dd2ed33931230710b20d
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.