Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Loading...
Loading
Contract Name:
Token
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-08-09 */ /** *Submitted for verification at Etherscan.io on 2022-08-08 */ // SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol) pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits. */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128) { require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits"); return int128(value); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64) { require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits"); return int64(value); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32) { require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits"); return int32(value); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16) { require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits"); return int16(value); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits. * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8) { require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits"); return int8(value); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } } // File: IVotes.sol // OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol) pragma solidity ^0.8.0; /** * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts. * * _Available since v4.5._ */ interface IVotes { /** * @dev Emitted when an account changes their delegate. */ event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /** * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes. */ event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance); /** * @dev Returns the current amount of votes that `account` has. */ function getVotes(address account) external view returns (uint256); /** * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`). */ function getPastVotes(address account, uint256 blockNumber) external view returns (uint256); /** * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`). * * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes. * Votes that have not been delegated are still part of total supply, even though they would not participate in a * vote. */ function getPastTotalSupply(uint256 blockNumber) external view returns (uint256); /** * @dev Returns the delegate that `account` has chosen. */ function delegates(address account) external view returns (address); /** * @dev Delegates votes from the sender to `delegatee`. */ function delegate(address delegatee) external; /** * @dev Delegates votes from signer to `delegatee`. */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) external; } // File: Math.sol // OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } } // File: Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: Strings.sol // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ 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); } } // File: ECDSA.sol // OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ 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)); } } // File: draft-EIP712.sol // OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol) pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ 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); } } // File: Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: IERC20.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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); } // File: IERC20Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File: ERC20.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) public _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 public _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, _allowances[owner][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = _allowances[owner][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Spend `amount` form the allowance of `owner` toward `spender`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // File: draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @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); } // File: draft-ERC20Permit.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/extensions/draft-ERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 { using Counters for Counters.Counter; mapping(address => Counters.Counter) private _nonces; // solhint-disable-next-line var-name-mixedcase bytes32 private constant _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT; /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") {} /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= deadline, "ERC20Permit: expired deadline"); bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)); bytes32 hash = _hashTypedDataV4(structHash); address signer = ECDSA.recover(hash, v, r, s); require(signer == owner, "ERC20Permit: invalid signature"); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view virtual override returns (uint256) { return _nonces[owner].current(); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return _domainSeparatorV4(); } /** * @dev "Consume a nonce": return the current value and increment. * * _Available since v4.1._ */ function _useNonce(address owner) internal virtual returns (uint256 current) { Counters.Counter storage nonce = _nonces[owner]; current = nonce.current(); nonce.increment(); } } // File: ERC20Votes.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Votes.sol) pragma solidity ^0.8.0; /** * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's, * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1. * * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module. * * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting * power can be queried through the public accessors {getVotes} and {getPastVotes}. * * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked. * * _Available since v4.2._ */ abstract contract ERC20Votes is IVotes, ERC20Permit { struct Checkpoint { uint32 fromBlock; uint224 votes; } bytes32 private constant _DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); mapping(address => address) private _delegates; mapping(address => Checkpoint[]) private _checkpoints; Checkpoint[] private _totalSupplyCheckpoints; /** * @dev Get the `pos`-th checkpoint for `account`. */ function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) { return _checkpoints[account][pos]; } /** * @dev Get number of checkpoints for `account`. */ function numCheckpoints(address account) public view virtual returns (uint32) { return SafeCast.toUint32(_checkpoints[account].length); } /** * @dev Get the address `account` is currently delegating to. */ function delegates(address account) public view virtual override returns (address) { return _delegates[account]; } /** * @dev Gets the current votes balance for `account` */ function getVotes(address account) public view virtual override returns (uint256) { uint256 pos = _checkpoints[account].length; return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes; } /** * @dev Retrieve the number of votes for `account` at the end of `blockNumber`. * * Requirements: * * - `blockNumber` must have been already mined */ function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_checkpoints[account], blockNumber); } /** * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances. * It is but NOT the sum of all the delegated votes! * * Requirements: * * - `blockNumber` must have been already mined */ function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) { require(blockNumber < block.number, "ERC20Votes: block not yet mined"); return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber); } /** * @dev Lookup a value in a list of (sorted) checkpoints. */ function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) { // We run a binary search to look for the earliest checkpoint taken after `blockNumber`. // // During the loop, the index of the wanted checkpoint remains in the range [low-1, high). // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant. // - If the middle checkpoint is after `blockNumber`, we look in [low, mid) // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high) // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not // out of bounds (in which case we're looking too far in the past and the result is 0). // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out // the same. uint256 high = ckpts.length; uint256 low = 0; while (low < high) { uint256 mid = Math.average(low, high); if (ckpts[mid].fromBlock > blockNumber) { high = mid; } else { low = mid + 1; } } return high == 0 ? 0 : ckpts[high - 1].votes; } /** * @dev Delegate votes from the sender to `delegatee`. */ function delegate(address delegatee) public virtual override { _delegate(_msgSender(), delegatee); } /** * @dev Delegates votes from signer to `delegatee` */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) public virtual override { require(block.timestamp <= expiry, "ERC20Votes: signature expired"); address signer = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))), v, r, s ); require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce"); _delegate(signer, delegatee); } /** * @dev Snapshots the totalSupply after it has been decreased. */ function _burn(address account, uint256 amount) internal virtual override { super._burn(account, amount); _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount); } /** * @dev Move voting power when tokens are transferred. * * Emits a {DelegateVotesChanged} event. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._afterTokenTransfer(from, to, amount); _moveVotingPower(delegates(from), delegates(to), amount); } /** * @dev Change delegation for `delegator` to `delegatee`. * * Emits events {DelegateChanged} and {DelegateVotesChanged}. */ function _delegate(address delegator, address delegatee) internal virtual { address currentDelegate = delegates(delegator); uint256 delegatorBalance = balanceOf(delegator); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveVotingPower(currentDelegate, delegatee, delegatorBalance); } function _moveVotingPower( address src, address dst, uint256 amount ) private { if (src != dst && amount > 0) { if (src != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount); emit DelegateVotesChanged(src, oldWeight, newWeight); } if (dst != address(0)) { (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount); emit DelegateVotesChanged(dst, oldWeight, newWeight); } } } function _writeCheckpoint( Checkpoint[] storage ckpts, function(uint256, uint256) view returns (uint256) op, uint256 delta ) private returns (uint256 oldWeight, uint256 newWeight) { uint256 pos = ckpts.length; oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes; newWeight = op(oldWeight, delta); if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) { ckpts[pos - 1].votes = SafeCast.toUint224(newWeight); } else { ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)})); } } function _add(uint256 a, uint256 b) private pure returns (uint256) { return a + b; } function _subtract(uint256 a, uint256 b) private pure returns (uint256) { return a - b; } } // File: SFM.sol pragma solidity ^0.8.0; contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view 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 onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Token is ERC20Votes, Ownable { constructor(uint256 amount) ERC20("SFMDAO", "SFM") ERC20Permit("SFMDAO") { require(msg.sender != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), msg.sender, amount); _totalSupply = amount; _balances[msg.sender] += amount; emit Transfer(address(0), msg.sender, amount); _afterTokenTransfer(address(0), msg.sender, amount); } // The functions below are overrides required by Solidity. function _afterTokenTransfer( address from, address to, uint256 amount ) internal override(ERC20Votes) { super._afterTokenTransfer(from, to, amount); } function _burn(address account, uint256 amount) internal override(ERC20Votes) { super._burn(account, amount); } function burn(uint256 _amount) external onlyOwner { _burn(msg.sender, _amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
6101406040523480156200001257600080fd5b5060405162004f0d38038062004f0d833981810160405281019062000038919062000bc7565b6040518060400160405280600681526020017f53464d44414f0000000000000000000000000000000000000000000000000000815250806040518060400160405280600181526020017f31000000000000000000000000000000000000000000000000000000000000008152506040518060400160405280600681526020017f53464d44414f00000000000000000000000000000000000000000000000000008152506040518060400160405280600381526020017f53464d000000000000000000000000000000000000000000000000000000000081525081600390805190602001906200012992919062000b00565b5080600490805190602001906200014292919062000b00565b50505060008280519060200120905060008280519060200120905060007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f90508260e081815250508161010081815250504660a08181525050620001ae8184846200041460201b60201c565b608081815250503073ffffffffffffffffffffffffffffffffffffffff1660c08173ffffffffffffffffffffffffffffffffffffffff1660601b8152505080610120818152505050505050505060006200020d6200045060201b60201c565b905080600a60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a350600073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156200031f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620003169062000d42565b60405180910390fd5b62000333600033836200045860201b60201c565b80600281905550806000803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546200038a919062000dbf565b925050819055503373ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051620003f1919062000d64565b60405180910390a36200040d600033836200045d60201b60201c565b5062001048565b600083838346306040516020016200043195949392919062000ca1565b6040516020818303038152906040528051906020012090509392505050565b600033905090565b505050565b620004758383836200047a60201b620013781760201c565b505050565b62000492838383620004ca60201b620013a31760201c565b620004c5620004a784620004cf60201b60201c565b620004b884620004cf60201b60201c565b836200053860201b60201c565b505050565b505050565b6000600760008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614158015620005755750600081115b156200075657600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161462000668576000806200060f600860008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206200075b60201b620013a817856200077360201b60201c565b915091508473ffffffffffffffffffffffffffffffffffffffff167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72483836040516200065d92919062000d81565b60405180910390a250505b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16146200075557600080620006fc600860008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002062000a2460201b620013be17856200077360201b60201c565b915091508373ffffffffffffffffffffffffffffffffffffffff167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72483836040516200074a92919062000d81565b60405180910390a250505b5b505050565b600081836200076b919062000e1c565b905092915050565b60008060008580549050905060008114620007e8578560018262000798919062000e1c565b81548110620007ac57620007ab62000f33565b5b9060005260206000200160000160049054906101000a90047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16620007eb565b60005b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1692506200081783858760201c565b9150600081118015620008705750438660018362000836919062000e1c565b815481106200084a576200084962000f33565b5b9060005260206000200160000160009054906101000a900463ffffffff1663ffffffff16145b1562000911576200088c8262000a3c60201b620013d41760201c565b866001836200089c919062000e1c565b81548110620008b057620008af62000f33565b5b9060005260206000200160000160046101000a8154817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff02191690837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16021790555062000a1b565b856040518060400160405280620009334362000aaa60201b6200143f1760201c565b63ffffffff168152602001620009548562000a3c60201b620013d41760201c565b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff168152509080600181540180825580915050600190039060005260206000200160009091909190915060008201518160000160006101000a81548163ffffffff021916908363ffffffff16021790555060208201518160000160046101000a8154817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff02191690837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16021790555050505b50935093915050565b6000818362000a34919062000dbf565b905092915050565b60007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff801682111562000aa2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040162000a999062000cfe565b60405180910390fd5b819050919050565b600063ffffffff801682111562000af8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040162000aef9062000d20565b60405180910390fd5b819050919050565b82805462000b0e9062000e9f565b90600052602060002090601f01602090048101928262000b32576000855562000b7e565b82601f1062000b4d57805160ff191683800117855562000b7e565b8280016001018555821562000b7e579182015b8281111562000b7d57825182559160200191906001019062000b60565b5b50905062000b8d919062000b91565b5090565b5b8082111562000bac57600081600090555060010162000b92565b5090565b60008151905062000bc1816200102e565b92915050565b60006020828403121562000be05762000bdf62000f62565b5b600062000bf08482850162000bb0565b91505092915050565b62000c048162000e57565b82525050565b62000c158162000e6b565b82525050565b600062000c2a60278362000dae565b915062000c378262000f67565b604082019050919050565b600062000c5160268362000dae565b915062000c5e8262000fb6565b604082019050919050565b600062000c78601f8362000dae565b915062000c858262001005565b602082019050919050565b62000c9b8162000e95565b82525050565b600060a08201905062000cb8600083018862000c0a565b62000cc7602083018762000c0a565b62000cd6604083018662000c0a565b62000ce5606083018562000c90565b62000cf4608083018462000bf9565b9695505050505050565b6000602082019050818103600083015262000d198162000c1b565b9050919050565b6000602082019050818103600083015262000d3b8162000c42565b9050919050565b6000602082019050818103600083015262000d5d8162000c69565b9050919050565b600060208201905062000d7b600083018462000c90565b92915050565b600060408201905062000d98600083018562000c90565b62000da7602083018462000c90565b9392505050565b600082825260208201905092915050565b600062000dcc8262000e95565b915062000dd98362000e95565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111562000e115762000e1062000ed5565b5b828201905092915050565b600062000e298262000e95565b915062000e368362000e95565b92508282101562000e4c5762000e4b62000ed5565b5b828203905092915050565b600062000e648262000e75565b9050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000600282049050600182168062000eb857607f821691505b6020821081141562000ecf5762000ece62000f04565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600080fd5b7f53616665436173743a2076616c756520646f65736e27742066697420696e203260008201527f3234206269747300000000000000000000000000000000000000000000000000602082015250565b7f53616665436173743a2076616c756520646f65736e27742066697420696e203360008201527f3220626974730000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b620010398162000e95565b81146200104557600080fd5b50565b60805160a05160c05160601c60e0516101005161012051613e726200109b6000396000611a2001526000611a6201526000611a4101526000611976015260006119cc015260006119f50152613e726000f3fe608060405234801561001057600080fd5b50600436106101c45760003560e01c806370a08231116100f9578063a457c2d711610097578063d505accf11610071578063d505accf14610569578063dd62ed3e14610585578063f1127ed8146105b5578063f2fde38b146105e5576101c4565b8063a457c2d7146104ed578063a9059cbb1461051d578063c3cda5201461054d576101c4565b80638da5cb5b116100d35780638da5cb5b146104515780638e539e8c1461046f57806395d89b411461049f5780639ab24eb0146104bd576101c4565b806370a08231146103e7578063715018a6146104175780637ecebe0014610421576101c4565b80633a46b1a811610166578063587cde1e11610140578063587cde1e1461033b5780635c19a95c1461036b5780636ebcf607146103875780636fcfff45146103b7576101c4565b80633a46b1a8146102d15780633eaaf86b1461030157806342966c681461031f576101c4565b806323b872dd116101a257806323b872dd14610235578063313ce567146102655780633644e5151461028357806339509351146102a1576101c4565b806306fdde03146101c9578063095ea7b3146101e757806318160ddd14610217575b600080fd5b6101d1610601565b6040516101de91906131cc565b60405180910390f35b61020160048036038101906101fc9190612ab0565b610693565b60405161020e9190613058565b60405180910390f35b61021f6106b6565b60405161022c91906134c9565b60405180910390f35b61024f600480360381019061024a91906129bb565b6106c0565b60405161025c9190613058565b60405180910390f35b61026d6106ef565b60405161027a9190613528565b60405180910390f35b61028b6106f8565b6040516102989190613073565b60405180910390f35b6102bb60048036038101906102b69190612ab0565b610707565b6040516102c89190613058565b60405180910390f35b6102eb60048036038101906102e69190612ab0565b6107b1565b6040516102f891906134c9565b60405180910390f35b610309610845565b60405161031691906134c9565b60405180910390f35b61033960048036038101906103349190612bbd565b61084b565b005b6103556004803603810190610350919061294e565b6108ef565b604051610362919061303d565b60405180910390f35b6103856004803603810190610380919061294e565b610958565b005b6103a1600480360381019061039c919061294e565b61096c565b6040516103ae91906134c9565b60405180910390f35b6103d160048036038101906103cc919061294e565b610984565b6040516103de919061350d565b60405180910390f35b61040160048036038101906103fc919061294e565b6109d8565b60405161040e91906134c9565b60405180910390f35b61041f610a20565b005b61043b6004803603810190610436919061294e565b610b78565b60405161044891906134c9565b60405180910390f35b610459610bc8565b604051610466919061303d565b60405180910390f35b61048960048036038101906104849190612bbd565b610bf2565b60405161049691906134c9565b60405180910390f35b6104a7610c48565b6040516104b491906131cc565b60405180910390f35b6104d760048036038101906104d2919061294e565b610cda565b6040516104e491906134c9565b60405180910390f35b61050760048036038101906105029190612ab0565b610deb565b6040516105149190613058565b60405180910390f35b61053760048036038101906105329190612ab0565b610ed5565b6040516105449190613058565b60405180910390f35b61056760048036038101906105629190612af0565b610ef8565b005b610583600480360381019061057e9190612a0e565b610ffc565b005b61059f600480360381019061059a919061297b565b61113e565b6040516105ac91906134c9565b60405180910390f35b6105cf60048036038101906105ca9190612b7d565b6111c5565b6040516105dc91906134ae565b60405180910390f35b6105ff60048036038101906105fa919061294e565b6112d5565b005b606060038054610610906136ef565b80601f016020809104026020016040519081016040528092919081815260200182805461063c906136ef565b80156106895780601f1061065e57610100808354040283529160200191610689565b820191906000526020600020905b81548152906001019060200180831161066c57829003601f168201915b5050505050905090565b60008061069e611492565b90506106ab81858561149a565b600191505092915050565b6000600254905090565b6000806106cb611492565b90506106d8858285611665565b6106e38585856116f1565b60019150509392505050565b60006012905090565b6000610702611972565b905090565b600080610712611492565b90506107a6818585600160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546107a1919061356a565b61149a565b600191505092915050565b60004382106107f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ec9061322e565b60405180910390fd5b61083d600860008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002083611a8c565b905092915050565b60025481565b610853611492565b73ffffffffffffffffffffffffffffffffffffffff16600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146108e2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108d9906133ce565b60405180910390fd5b6108ec3382611b98565b50565b6000600760008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b610969610963611492565b82611ba6565b50565b60006020528060005260406000206000915090505481565b60006109d1600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208054905061143f565b9050919050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b610a28611492565b73ffffffffffffffffffffffffffffffffffffffff16600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610ab7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610aae906133ce565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff16600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a36000600a60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b6000610bc1600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020611cc0565b9050919050565b6000600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000438210610c36576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c2d9061322e565b60405180910390fd5b610c41600983611a8c565b9050919050565b606060048054610c57906136ef565b80601f0160208091040260200160405190810160405280929190818152602001828054610c83906136ef565b8015610cd05780601f10610ca557610100808354040283529160200191610cd0565b820191906000526020600020905b815481529060010190602001808311610cb357829003601f168201915b5050505050905090565b600080600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002080549050905060008114610dc257600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600182610d7691906135f1565b81548110610d8757610d866137e7565b5b9060005260206000200160000160049054906101000a90047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16610dc5565b60005b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16915050919050565b600080610df6611492565b90506000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905083811015610ebc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eb39061348e565b60405180910390fd5b610ec9828686840361149a565b60019250505092915050565b600080610ee0611492565b9050610eed8185856116f1565b600191505092915050565b83421115610f3b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f329061324e565b60405180910390fd5b6000610f9d610f957fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf898989604051602001610f7a94939291906130ef565b60405160208183030381529060405280519060200120611cce565b858585611ce8565b9050610fa881611d13565b8614610fe9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fe0906132ae565b60405180910390fd5b610ff38188611ba6565b50505050505050565b8342111561103f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110369061332e565b60405180910390fd5b60007f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c988888861106e8c611d13565b896040516020016110849695949392919061308e565b60405160208183030381529060405280519060200120905060006110a782611cce565b905060006110b782878787611ce8565b90508973ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614611127576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111e906133ae565b60405180910390fd5b6111328a8a8a61149a565b50505050505050505050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b6111cd6128a7565b600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208263ffffffff1681548110611224576112236137e7565b5b906000526020600020016040518060400160405290816000820160009054906101000a900463ffffffff1663ffffffff1663ffffffff1681526020016000820160049054906101000a90047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1681525050905092915050565b6112dd611492565b73ffffffffffffffffffffffffffffffffffffffff16600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461136c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611363906133ce565b60405180910390fd5b61137581611d71565b50565b6113838383836113a3565b61139e61138f846108ef565b611398846108ef565b83611ea1565b505050565b505050565b600081836113b691906135f1565b905092915050565b600081836113cc919061356a565b905092915050565b60007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8016821115611437576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161142e906133ee565b60405180910390fd5b819050919050565b600063ffffffff801682111561148a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114819061344e565b60405180910390fd5b819050919050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561150a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115019061346e565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561157a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611571906132ee565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161165891906134c9565b60405180910390a3505050565b6000611671848461113e565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81146116eb57818110156116dd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116d49061330e565b60405180910390fd5b6116ea848484840361149a565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611761576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117589061342e565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156117d1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117c89061320e565b60405180910390fd5b6117dc83838361209a565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611862576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118599061334e565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546118f5919061356a565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161195991906134c9565b60405180910390a361196c84848461209f565b50505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161480156119ee57507f000000000000000000000000000000000000000000000000000000000000000046145b15611a1b577f00000000000000000000000000000000000000000000000000000000000000009050611a89565b611a867f00000000000000000000000000000000000000000000000000000000000000007f00000000000000000000000000000000000000000000000000000000000000007f00000000000000000000000000000000000000000000000000000000000000006120af565b90505b90565b6000808380549050905060005b81811015611b0b576000611aad82846120e9565b905084868281548110611ac357611ac26137e7565b5b9060005260206000200160000160009054906101000a900463ffffffff1663ffffffff161115611af557809250611b05565b600181611b02919061356a565b91505b50611a99565b60008214611b6d5784600183611b2191906135f1565b81548110611b3257611b316137e7565b5b9060005260206000200160000160049054906101000a90047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16611b70565b60005b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff169250505092915050565b611ba2828261210f565b5050565b6000611bb1836108ef565b90506000611bbe846109d8565b905082600760008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508273ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f60405160405180910390a4611cba828483611ea1565b50505050565b600081600001549050919050565b6000611ce1611cdb611972565b8361212d565b9050919050565b6000806000611cf987878787612160565b91509150611d068161226d565b8192505050949350505050565b600080600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050611d6081611cc0565b9150611d6b81612442565b50919050565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611de1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dd8906132ce565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff16600a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a380600a60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614158015611edd5750600081115b1561209557600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614611fbb57600080611f64600860008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206113a885612458565b915091508473ffffffffffffffffffffffffffffffffffffffff167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a7248383604051611fb09291906134e4565b60405180910390a250505b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16146120945760008061203d600860008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206113be85612458565b915091508373ffffffffffffffffffffffffffffffffffffffff167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72483836040516120899291906134e4565b60405180910390a250505b5b505050565b505050565b6120aa838383611378565b505050565b600083838346306040516020016120ca959493929190613134565b6040516020818303038152906040528051906020012090509392505050565b600060028284186120fa91906135c0565b828416612107919061356a565b905092915050565b61211982826126d0565b61212760096113a883612458565b50505050565b60008282604051602001612142929190613006565b60405160208183030381529060405280519060200120905092915050565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08360001c111561219b576000600391509150612264565b601b8560ff16141580156121b35750601c8560ff1614155b156121c5576000600491509150612264565b6000600187878787604051600081526020016040526040516121ea9493929190613187565b6020604051602081039080840390855afa15801561220c573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561225b57600060019250925050612264565b80600092509250505b94509492505050565b6000600481111561228157612280613789565b5b81600481111561229457612293613789565b5b141561229f5761243f565b600160048111156122b3576122b2613789565b5b8160048111156122c6576122c5613789565b5b1415612307576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122fe906131ee565b60405180910390fd5b6002600481111561231b5761231a613789565b5b81600481111561232e5761232d613789565b5b141561236f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123669061328e565b60405180910390fd5b6003600481111561238357612382613789565b5b81600481111561239657612395613789565b5b14156123d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123ce9061336e565b60405180910390fd5b6004808111156123ea576123e9613789565b5b8160048111156123fd576123fc613789565b5b141561243e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016124359061338e565b60405180910390fd5b5b50565b6001816000016000828254019250508190555050565b600080600085805490509050600081146124c6578560018261247a91906135f1565b8154811061248b5761248a6137e7565b5b9060005260206000200160000160049054906101000a90047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff166124c9565b60005b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1692506124f783858763ffffffff16565b915060008111801561254a5750438660018361251391906135f1565b81548110612524576125236137e7565b5b9060005260206000200160000160009054906101000a900463ffffffff1663ffffffff16145b156125d757612558826113d4565b8660018361256691906135f1565b81548110612577576125766137e7565b5b9060005260206000200160000160046101000a8154817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff02191690837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1602179055506126c7565b8560405180604001604052806125ec4361143f565b63ffffffff168152602001612600856113d4565b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff168152509080600181540180825580915050600190039060005260206000200160009091909190915060008201518160000160006101000a81548163ffffffff021916908363ffffffff16021790555060208201518160000160046101000a8154817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff02191690837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16021790555050505b50935093915050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415612740576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016127379061340e565b60405180910390fd5b61274c8260008361209a565b60008060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156127d2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016127c99061326e565b60405180910390fd5b8181036000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816002600082825461282991906135f1565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161288e91906134c9565b60405180910390a36128a28360008461209f565b505050565b6040518060400160405280600063ffffffff16815260200160007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1681525090565b6000813590506128f481613dc9565b92915050565b60008135905061290981613de0565b92915050565b60008135905061291e81613df7565b92915050565b60008135905061293381613e0e565b92915050565b60008135905061294881613e25565b92915050565b60006020828403121561296457612963613816565b5b6000612972848285016128e5565b91505092915050565b6000806040838503121561299257612991613816565b5b60006129a0858286016128e5565b92505060206129b1858286016128e5565b9150509250929050565b6000806000606084860312156129d4576129d3613816565b5b60006129e2868287016128e5565b93505060206129f3868287016128e5565b9250506040612a048682870161290f565b9150509250925092565b600080600080600080600060e0888a031215612a2d57612a2c613816565b5b6000612a3b8a828b016128e5565b9750506020612a4c8a828b016128e5565b9650506040612a5d8a828b0161290f565b9550506060612a6e8a828b0161290f565b9450506080612a7f8a828b01612939565b93505060a0612a908a828b016128fa565b92505060c0612aa18a828b016128fa565b91505092959891949750929550565b60008060408385031215612ac757612ac6613816565b5b6000612ad5858286016128e5565b9250506020612ae68582860161290f565b9150509250929050565b60008060008060008060c08789031215612b0d57612b0c613816565b5b6000612b1b89828a016128e5565b9650506020612b2c89828a0161290f565b9550506040612b3d89828a0161290f565b9450506060612b4e89828a01612939565b9350506080612b5f89828a016128fa565b92505060a0612b7089828a016128fa565b9150509295509295509295565b60008060408385031215612b9457612b93613816565b5b6000612ba2858286016128e5565b9250506020612bb385828601612924565b9150509250929050565b600060208284031215612bd357612bd2613816565b5b6000612be18482850161290f565b91505092915050565b612bf381613625565b82525050565b612c0281613637565b82525050565b612c1181613643565b82525050565b612c28612c2382613643565b613721565b82525050565b6000612c3982613543565b612c43818561354e565b9350612c538185602086016136bc565b612c5c8161381b565b840191505092915050565b6000612c7460188361354e565b9150612c7f8261382c565b602082019050919050565b6000612c9760238361354e565b9150612ca282613855565b604082019050919050565b6000612cba601f8361354e565b9150612cc5826138a4565b602082019050919050565b6000612cdd601d8361354e565b9150612ce8826138cd565b602082019050919050565b6000612d0060228361354e565b9150612d0b826138f6565b604082019050919050565b6000612d23601f8361354e565b9150612d2e82613945565b602082019050919050565b6000612d4660198361354e565b9150612d518261396e565b602082019050919050565b6000612d6960268361354e565b9150612d7482613997565b604082019050919050565b6000612d8c60228361354e565b9150612d97826139e6565b604082019050919050565b6000612daf60028361355f565b9150612dba82613a35565b600282019050919050565b6000612dd2601d8361354e565b9150612ddd82613a5e565b602082019050919050565b6000612df5601d8361354e565b9150612e0082613a87565b602082019050919050565b6000612e1860268361354e565b9150612e2382613ab0565b604082019050919050565b6000612e3b60228361354e565b9150612e4682613aff565b604082019050919050565b6000612e5e60228361354e565b9150612e6982613b4e565b604082019050919050565b6000612e81601e8361354e565b9150612e8c82613b9d565b602082019050919050565b6000612ea460208361354e565b9150612eaf82613bc6565b602082019050919050565b6000612ec760278361354e565b9150612ed282613bef565b604082019050919050565b6000612eea60218361354e565b9150612ef582613c3e565b604082019050919050565b6000612f0d60258361354e565b9150612f1882613c8d565b604082019050919050565b6000612f3060268361354e565b9150612f3b82613cdc565b604082019050919050565b6000612f5360248361354e565b9150612f5e82613d2b565b604082019050919050565b6000612f7660258361354e565b9150612f8182613d7a565b604082019050919050565b604082016000820151612fa26000850182612fd9565b506020820151612fb56020850182612fbb565b50505050565b612fc48161366d565b82525050565b612fd381613695565b82525050565b612fe28161369f565b82525050565b612ff18161369f565b82525050565b613000816136af565b82525050565b600061301182612da2565b915061301d8285612c17565b60208201915061302d8284612c17565b6020820191508190509392505050565b60006020820190506130526000830184612bea565b92915050565b600060208201905061306d6000830184612bf9565b92915050565b60006020820190506130886000830184612c08565b92915050565b600060c0820190506130a36000830189612c08565b6130b06020830188612bea565b6130bd6040830187612bea565b6130ca6060830186612fca565b6130d76080830185612fca565b6130e460a0830184612fca565b979650505050505050565b60006080820190506131046000830187612c08565b6131116020830186612bea565b61311e6040830185612fca565b61312b6060830184612fca565b95945050505050565b600060a0820190506131496000830188612c08565b6131566020830187612c08565b6131636040830186612c08565b6131706060830185612fca565b61317d6080830184612bea565b9695505050505050565b600060808201905061319c6000830187612c08565b6131a96020830186612ff7565b6131b66040830185612c08565b6131c36060830184612c08565b95945050505050565b600060208201905081810360008301526131e68184612c2e565b905092915050565b6000602082019050818103600083015261320781612c67565b9050919050565b6000602082019050818103600083015261322781612c8a565b9050919050565b6000602082019050818103600083015261324781612cad565b9050919050565b6000602082019050818103600083015261326781612cd0565b9050919050565b6000602082019050818103600083015261328781612cf3565b9050919050565b600060208201905081810360008301526132a781612d16565b9050919050565b600060208201905081810360008301526132c781612d39565b9050919050565b600060208201905081810360008301526132e781612d5c565b9050919050565b6000602082019050818103600083015261330781612d7f565b9050919050565b6000602082019050818103600083015261332781612dc5565b9050919050565b6000602082019050818103600083015261334781612de8565b9050919050565b6000602082019050818103600083015261336781612e0b565b9050919050565b6000602082019050818103600083015261338781612e2e565b9050919050565b600060208201905081810360008301526133a781612e51565b9050919050565b600060208201905081810360008301526133c781612e74565b9050919050565b600060208201905081810360008301526133e781612e97565b9050919050565b6000602082019050818103600083015261340781612eba565b9050919050565b6000602082019050818103600083015261342781612edd565b9050919050565b6000602082019050818103600083015261344781612f00565b9050919050565b6000602082019050818103600083015261346781612f23565b9050919050565b6000602082019050818103600083015261348781612f46565b9050919050565b600060208201905081810360008301526134a781612f69565b9050919050565b60006040820190506134c36000830184612f8c565b92915050565b60006020820190506134de6000830184612fca565b92915050565b60006040820190506134f96000830185612fca565b6135066020830184612fca565b9392505050565b60006020820190506135226000830184612fe8565b92915050565b600060208201905061353d6000830184612ff7565b92915050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600061357582613695565b915061358083613695565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156135b5576135b461372b565b5b828201905092915050565b60006135cb82613695565b91506135d683613695565b9250826135e6576135e561375a565b5b828204905092915050565b60006135fc82613695565b915061360783613695565b92508282101561361a5761361961372b565b5b828203905092915050565b60006136308261364d565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600063ffffffff82169050919050565b600060ff82169050919050565b60005b838110156136da5780820151818401526020810190506136bf565b838111156136e9576000848401525b50505050565b6000600282049050600182168061370757607f821691505b6020821081141561371b5761371a6137b8565b5b50919050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45434453413a20696e76616c6964207369676e61747572650000000000000000600082015250565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433230566f7465733a20626c6f636b206e6f7420796574206d696e656400600082015250565b7f4552433230566f7465733a207369676e61747572652065787069726564000000600082015250565b7f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60008201527f6365000000000000000000000000000000000000000000000000000000000000602082015250565b7f45434453413a20696e76616c6964207369676e6174757265206c656e67746800600082015250565b7f4552433230566f7465733a20696e76616c6964206e6f6e636500000000000000600082015250565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f1901000000000000000000000000000000000000000000000000000000000000600082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332305065726d69743a206578706972656420646561646c696e65000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45434453413a20696e76616c6964207369676e6174757265202773272076616c60008201527f7565000000000000000000000000000000000000000000000000000000000000602082015250565b7f45434453413a20696e76616c6964207369676e6174757265202776272076616c60008201527f7565000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332305065726d69743a20696e76616c6964207369676e61747572650000600082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f53616665436173743a2076616c756520646f65736e27742066697420696e203260008201527f3234206269747300000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360008201527f7300000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f53616665436173743a2076616c756520646f65736e27742066697420696e203360008201527f3220626974730000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b613dd281613625565b8114613ddd57600080fd5b50565b613de981613643565b8114613df457600080fd5b50565b613e0081613695565b8114613e0b57600080fd5b50565b613e178161369f565b8114613e2257600080fd5b50565b613e2e816136af565b8114613e3957600080fd5b5056fea2646970667358221220a692a7169c1b76e00977e7471267421de7dd733fbfca72e6d580b6a33951a01564736f6c634300080700330000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
-----Decoded View---------------
Arg [0] : amount (uint256): 1000000000000000000000000000
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Deployed Bytecode Sourcemap
61444:1004:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35627:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37978:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36747:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38759:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36589:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50518:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39463:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53681:268;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35035:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62350:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53055:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56154:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34906:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52811:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36918:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60775:125;;;:::i;:::-;;50260:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60201:70;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54238:259;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35846:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53267:212;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40206:438;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37251:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56350:591;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49549:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37507:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52581:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61037:100;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35627;35681:13;35714:5;35707:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35627:100;:::o;37978:201::-;38061:4;38078:13;38094:12;:10;:12::i;:::-;38078:28;;38117:32;38126:5;38133:7;38142:6;38117:8;:32::i;:::-;38167:4;38160:11;;;37978:201;;;;:::o;36747:108::-;36808:7;36835:12;;36828:19;;36747:108;:::o;38759:295::-;38890:4;38907:15;38925:12;:10;:12::i;:::-;38907:30;;38948:38;38964:4;38970:7;38979:6;38948:15;:38::i;:::-;38997:27;39007:4;39013:2;39017:6;38997:9;:27::i;:::-;39042:4;39035:11;;;38759:295;;;;;:::o;36589:93::-;36647:5;36672:2;36665:9;;36589:93;:::o;50518:115::-;50578:7;50605:20;:18;:20::i;:::-;50598:27;;50518:115;:::o;39463:240::-;39551:4;39568:13;39584:12;:10;:12::i;:::-;39568:28;;39607:66;39616:5;39623:7;39662:10;39632:11;:18;39644:5;39632:18;;;;;;;;;;;;;;;:27;39651:7;39632:27;;;;;;;;;;;;;;;;:40;;;;:::i;:::-;39607:8;:66::i;:::-;39691:4;39684:11;;;39463:240;;;;:::o;53681:268::-;53779:7;53821:12;53807:11;:26;53799:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;53887:54;53906:12;:21;53919:7;53906:21;;;;;;;;;;;;;;;53929:11;53887:18;:54::i;:::-;53880:61;;53681:268;;;;:::o;35035:27::-;;;;:::o;62350:95::-;60394:12;:10;:12::i;:::-;60384:22;;:6;;;;;;;;;;;:22;;;60376:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;62411:26:::1;62417:10;62429:7;62411:5;:26::i;:::-;62350:95:::0;:::o;53055:128::-;53129:7;53156:10;:19;53167:7;53156:19;;;;;;;;;;;;;;;;;;;;;;;;;53149:26;;53055:128;;;:::o;56154:114::-;56226:34;56236:12;:10;:12::i;:::-;56250:9;56226;:34::i;:::-;56154:114;:::o;34906:44::-;;;;;;;;;;;;;;;;;:::o;52811:151::-;52881:6;52907:47;52925:12;:21;52938:7;52925:21;;;;;;;;;;;;;;;:28;;;;52907:17;:47::i;:::-;52900:54;;52811:151;;;:::o;36918:127::-;36992:7;37019:9;:18;37029:7;37019:18;;;;;;;;;;;;;;;;37012:25;;36918:127;;;:::o;60775:125::-;60394:12;:10;:12::i;:::-;60384:22;;:6;;;;;;;;;;;:22;;;60376:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;60868:1:::1;60831:40;;60852:6;;;;;;;;;;;60831:40;;;;;;;;;;;;60893:1;60876:6;;:19;;;;;;;;;;;;;;;;;;60775:125::o:0;50260:128::-;50329:7;50356:24;:7;:14;50364:5;50356:14;;;;;;;;;;;;;;;:22;:24::i;:::-;50349:31;;50260:128;;;:::o;60201:70::-;60239:7;60260:6;;;;;;;;;;;60253:13;;60201:70;:::o;54238:259::-;54325:7;54367:12;54353:11;:26;54345:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;54433:56;54452:23;54477:11;54433:18;:56::i;:::-;54426:63;;54238:259;;;:::o;35846:104::-;35902:13;35935:7;35928:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35846:104;:::o;53267:212::-;53340:7;53360:11;53374:12;:21;53387:7;53374:21;;;;;;;;;;;;;;;:28;;;;53360:42;;53427:1;53420:3;:8;:51;;53435:12;:21;53448:7;53435:21;;;;;;;;;;;;;;;53463:1;53457:3;:7;;;;:::i;:::-;53435:30;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;;;;;;;;;53420:51;;;53431:1;53420:51;53413:58;;;;;53267:212;;;:::o;40206:438::-;40299:4;40316:13;40332:12;:10;:12::i;:::-;40316:28;;40355:24;40382:11;:18;40394:5;40382:18;;;;;;;;;;;;;;;:27;40401:7;40382:27;;;;;;;;;;;;;;;;40355:54;;40448:15;40428:16;:35;;40420:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;40541:60;40550:5;40557:7;40585:15;40566:16;:34;40541:8;:60::i;:::-;40632:4;40625:11;;;;40206:438;;;;:::o;37251:193::-;37330:4;37347:13;37363:12;:10;:12::i;:::-;37347:28;;37386;37396:5;37403:2;37407:6;37386:9;:28::i;:::-;37432:4;37425:11;;;37251:193;;;;:::o;56350:591::-;56577:6;56558:15;:25;;56550:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;56628:14;56645:174;56673:87;52261:71;56733:9;56744:5;56751:6;56700:58;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;56690:69;;;;;;56673:16;:87::i;:::-;56775:1;56791;56807;56645:13;:174::i;:::-;56628:191;;56847:17;56857:6;56847:9;:17::i;:::-;56838:5;:26;56830:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;56905:28;56915:6;56923:9;56905;:28::i;:::-;56539:402;56350:591;;;;;;:::o;49549:645::-;49793:8;49774:15;:27;;49766:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;49848:18;49040:95;49908:5;49915:7;49924:5;49931:16;49941:5;49931:9;:16::i;:::-;49949:8;49879:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49869:90;;;;;;49848:111;;49972:12;49987:28;50004:10;49987:16;:28::i;:::-;49972:43;;50028:14;50045:28;50059:4;50065:1;50068;50071;50045:13;:28::i;:::-;50028:45;;50102:5;50092:15;;:6;:15;;;50084:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50155:31;50164:5;50171:7;50180:5;50155:8;:31::i;:::-;49755:439;;;49549:645;;;;;;;:::o;37507:151::-;37596:7;37623:11;:18;37635:5;37623:18;;;;;;;;;;;;;;;:27;37642:7;37623:27;;;;;;;;;;;;;;;;37616:34;;37507:151;;;;:::o;52581:150::-;52660:17;;:::i;:::-;52697:12;:21;52710:7;52697:21;;;;;;;;;;;;;;;52719:3;52697:26;;;;;;;;;;:::i;:::-;;;;;;;;;52690:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52581:150;;;;:::o;61037:100::-;60394:12;:10;:12::i;:::-;60384:22;;:6;;;;;;;;;;;:22;;;60376:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;61104:28:::1;61123:8;61104:18;:28::i;:::-;61037:100:::0;:::o;57371:262::-;57513:43;57539:4;57545:2;57549:6;57513:25;:43::i;:::-;57569:56;57586:15;57596:4;57586:9;:15::i;:::-;57603:13;57613:2;57603:9;:13::i;:::-;57618:6;57569:16;:56::i;:::-;57371:262;;;:::o;45613:124::-;;;;:::o;59603:103::-;59666:7;59697:1;59693;:5;;;;:::i;:::-;59686:12;;59603:103;;;;:::o;59497:98::-;59555:7;59586:1;59582;:5;;;;:::i;:::-;59575:12;;59497:98;;;;:::o;1241:195::-;1298:7;1335:17;1326:26;;:5;:26;;1318:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;1422:5;1407:21;;1241:195;;;:::o;3211:190::-;3267:6;3303:16;3294:25;;:5;:25;;3286:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;3387:5;3373:20;;3211:190;;;:::o;29774:98::-;29827:7;29854:10;29847:17;;29774:98;:::o;43164:380::-;43317:1;43300:19;;:5;:19;;;;43292:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;43398:1;43379:21;;:7;:21;;;;43371:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;43482:6;43452:11;:18;43464:5;43452:18;;;;;;;;;;;;;;;:27;43471:7;43452:27;;;;;;;;;;;;;;;:36;;;;43520:7;43504:32;;43513:5;43504:32;;;43529:6;43504:32;;;;;;:::i;:::-;;;;;;;;43164:380;;;:::o;43831:453::-;43966:24;43993:25;44003:5;44010:7;43993:9;:25::i;:::-;43966:52;;44053:17;44033:16;:37;44029:248;;44115:6;44095:16;:26;;44087:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44199:51;44208:5;44215:7;44243:6;44224:16;:25;44199:8;:51::i;:::-;44029:248;43955:329;43831:453;;;:::o;41123:671::-;41270:1;41254:18;;:4;:18;;;;41246:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41347:1;41333:16;;:2;:16;;;;41325:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;41402:38;41423:4;41429:2;41433:6;41402:20;:38::i;:::-;41453:19;41475:9;:15;41485:4;41475:15;;;;;;;;;;;;;;;;41453:37;;41524:6;41509:11;:21;;41501:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;41641:6;41627:11;:20;41609:9;:15;41619:4;41609:15;;;;;;;;;;;;;;;:38;;;;41686:6;41669:9;:13;41679:2;41669:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;41725:2;41710:26;;41719:4;41710:26;;;41729:6;41710:26;;;;;;:::i;:::-;;;;;;;;41749:37;41769:4;41775:2;41779:6;41749:19;:37::i;:::-;41235:559;41123:671;;;:::o;27724:314::-;27777:7;27818:12;27801:29;;27809:4;27801:29;;;:66;;;;;27851:16;27834:13;:33;27801:66;27797:234;;;27891:24;27884:31;;;;27797:234;27955:64;27977:10;27989:12;28003:15;27955:21;:64::i;:::-;27948:71;;27724:314;;:::o;54586:1482::-;54685:7;55704:12;55719:5;:12;;;;55704:27;;55742:11;55768:236;55781:4;55775:3;:10;55768:236;;;55802:11;55816:23;55829:3;55834:4;55816:12;:23::i;:::-;55802:37;;55881:11;55858:5;55864:3;55858:10;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;:34;;;55854:139;;;55920:3;55913:10;;55854:139;;;55976:1;55970:3;:7;;;;:::i;:::-;55964:13;;55854:139;55787:217;55768:236;;;56031:1;56023:4;:9;:37;;56039:5;56052:1;56045:4;:8;;;;:::i;:::-;56039:15;;;;;;;;:::i;:::-;;;;;;;;;:21;;;;;;;;;;;;56023:37;;;56035:1;56023:37;56016:44;;;;;;54586:1482;;;;:::o;62194:148::-;62306:28;62318:7;62327:6;62306:11;:28::i;:::-;62194:148;;:::o;57797:388::-;57882:23;57908:20;57918:9;57908;:20::i;:::-;57882:46;;57939:24;57966:20;57976:9;57966;:20::i;:::-;57939:47;;58021:9;57997:10;:21;58008:9;57997:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;58092:9;58048:54;;58075:15;58048:54;;58064:9;58048:54;;;;;;;;;;;;58115:62;58132:15;58149:9;58160:16;58115;:62::i;:::-;57871:314;;57797:388;;:::o;12359:114::-;12424:7;12451;:14;;;12444:21;;12359:114;;;:::o;28951:167::-;29028:7;29055:55;29077:20;:18;:20::i;:::-;29099:10;29055:21;:55::i;:::-;29048:62;;28951:167;;;:::o;22643:279::-;22771:7;22792:17;22811:18;22833:25;22844:4;22850:1;22853;22856;22833:10;:25::i;:::-;22791:67;;;;22869:18;22881:5;22869:11;:18::i;:::-;22905:9;22898:16;;;;22643:279;;;;;;:::o;50771:207::-;50831:15;50859:30;50892:7;:14;50900:5;50892:14;;;;;;;;;;;;;;;50859:47;;50927:15;:5;:13;:15::i;:::-;50917:25;;50953:17;:5;:15;:17::i;:::-;50848:130;50771:207;;;:::o;61229:208::-;61317:1;61297:22;;:8;:22;;;;61289:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;61401:8;61372:38;;61393:6;;;;;;;;;;;61372:38;;;;;;;;;;;;61424:8;61415:6;;:17;;;;;;;;;;;;;;;;;;61229:208;:::o;58193:643::-;58325:3;58318:10;;:3;:10;;;;:24;;;;;58341:1;58332:6;:10;58318:24;58314:515;;;58378:1;58363:17;;:3;:17;;;58359:224;;58402:17;58421;58442:54;58459:12;:17;58472:3;58459:17;;;;;;;;;;;;;;;58478:9;58489:6;58442:16;:54::i;:::-;58401:95;;;;58541:3;58520:47;;;58546:9;58557;58520:47;;;;;;;:::i;:::-;;;;;;;;58382:201;;58359:224;58618:1;58603:17;;:3;:17;;;58599:219;;58642:17;58661;58682:49;58699:12;:17;58712:3;58699:17;;;;;;;;;;;;;;;58718:4;58724:6;58682:16;:49::i;:::-;58641:90;;;;58776:3;58755:47;;;58781:9;58792;58755:47;;;;;;;:::i;:::-;;;;;;;;58622:196;;58599:219;58314:515;58193:643;;;:::o;44884:125::-;;;;:::o;61982:197::-;62128:43;62154:4;62160:2;62164:6;62128:25;:43::i;:::-;61982:197;;;:::o;28046:263::-;28190:7;28238:8;28248;28258:11;28271:13;28294:4;28227:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;28217:84;;;;;;28210:91;;28046:263;;;;;:::o;10950:156::-;11012:7;11097:1;11092;11088;:5;11087:11;;;;:::i;:::-;11082:1;11078;:5;11077:21;;;;:::i;:::-;11070:28;;10950:156;;;;:::o;57037:194::-;57122:28;57134:7;57143:6;57122:11;:28::i;:::-;57163:60;57180:23;57205:9;57216:6;57163:16;:60::i;:::-;;;57037:194;;:::o;24334:196::-;24427:7;24493:15;24510:10;24464:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24454:68;;;;;;24447:75;;24334:196;;;;:::o;20872:1632::-;21003:7;21012:12;21937:66;21932:1;21924:10;;:79;21920:163;;;22036:1;22040:30;22020:51;;;;;;21920:163;22102:2;22097:1;:7;;;;:18;;;;;22113:2;22108:1;:7;;;;22097:18;22093:102;;;22148:1;22152:30;22132:51;;;;;;22093:102;22292:14;22309:24;22319:4;22325:1;22328;22331;22309:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22292:41;;22366:1;22348:20;;:6;:20;;;22344:103;;;22401:1;22405:29;22385:50;;;;;;;22344:103;22467:6;22475:20;22459:37;;;;;20872:1632;;;;;;;;:::o;15581:643::-;15659:20;15650:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;15646:571;;;15696:7;;15646:571;15757:29;15748:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;15744:473;;;15803:34;;;;;;;;;;:::i;:::-;;;;;;;;15744:473;15868:35;15859:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;15855:362;;;15920:41;;;;;;;;;;:::i;:::-;;;;;;;;15855:362;15992:30;15983:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;15979:238;;;16039:44;;;;;;;;;;:::i;:::-;;;;;;;;15979:238;16114:30;16105:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;16101:116;;;16161:44;;;;;;;;;;:::i;:::-;;;;;;;;16101:116;15581:643;;:::o;12481:127::-;12588:1;12570:7;:14;;;:19;;;;;;;;;;;12481:127;:::o;58844:645::-;59018:17;59037;59067:11;59081:5;:12;;;;59067:26;;59123:1;59116:3;:8;:35;;59131:5;59143:1;59137:3;:7;;;;:::i;:::-;59131:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;59116:35;;;59127:1;59116:35;59104:47;;;;59174:20;59177:9;59188:5;59174:2;:20;;:::i;:::-;59162:32;;59217:1;59211:3;:7;:51;;;;;59250:12;59222:5;59234:1;59228:3;:7;;;;:::i;:::-;59222:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;;;;;;;;;:40;;;59211:51;59207:275;;;59302:29;59321:9;59302:18;:29::i;:::-;59279:5;59291:1;59285:3;:7;;;;:::i;:::-;59279:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;:52;;;;;;;;;;;;;;;;;;59207:275;;;59364:5;59375:94;;;;;;;;59398:31;59416:12;59398:17;:31::i;:::-;59375:94;;;;;;59438:29;59457:9;59438:18;:29::i;:::-;59375:94;;;;;59364:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59207:275;59056:433;58844:645;;;;;;:::o;42135:591::-;42238:1;42219:21;;:7;:21;;;;42211:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;42291:49;42312:7;42329:1;42333:6;42291:20;:49::i;:::-;42353:22;42378:9;:18;42388:7;42378:18;;;;;;;;;;;;;;;;42353:43;;42433:6;42415:14;:24;;42407:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;42552:6;42535:14;:23;42514:9;:18;42524:7;42514:18;;;;;;;;;;;;;;;:44;;;;42596:6;42580:12;;:22;;;;;;;:::i;:::-;;;;;;;;42646:1;42620:37;;42629:7;42620:37;;;42650:6;42620:37;;;;;;:::i;:::-;;;;;;;;42670:48;42690:7;42707:1;42711:6;42670:19;:48::i;:::-;42200:526;42135:591;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;152:139;;;;:::o;297:::-;343:5;381:6;368:20;359:29;;397:33;424:5;397:33;:::i;:::-;297:139;;;;:::o;442:137::-;487:5;525:6;512:20;503:29;;541:32;567:5;541:32;:::i;:::-;442:137;;;;:::o;585:135::-;629:5;667:6;654:20;645:29;;683:31;708:5;683:31;:::i;:::-;585:135;;;;:::o;726:329::-;785:6;834:2;822:9;813:7;809:23;805:32;802:119;;;840:79;;:::i;:::-;802:119;960:1;985:53;1030:7;1021:6;1010:9;1006:22;985:53;:::i;:::-;975:63;;931:117;726:329;;;;:::o;1061:474::-;1129:6;1137;1186:2;1174:9;1165:7;1161:23;1157:32;1154:119;;;1192:79;;:::i;:::-;1154:119;1312:1;1337:53;1382:7;1373:6;1362:9;1358:22;1337:53;:::i;:::-;1327:63;;1283:117;1439:2;1465:53;1510:7;1501:6;1490:9;1486:22;1465:53;:::i;:::-;1455:63;;1410:118;1061:474;;;;;:::o;1541:619::-;1618:6;1626;1634;1683:2;1671:9;1662:7;1658:23;1654:32;1651:119;;;1689:79;;:::i;:::-;1651:119;1809:1;1834:53;1879:7;1870:6;1859:9;1855:22;1834:53;:::i;:::-;1824:63;;1780:117;1936:2;1962:53;2007:7;1998:6;1987:9;1983:22;1962:53;:::i;:::-;1952:63;;1907:118;2064:2;2090:53;2135:7;2126:6;2115:9;2111:22;2090:53;:::i;:::-;2080:63;;2035:118;1541:619;;;;;:::o;2166:1199::-;2277:6;2285;2293;2301;2309;2317;2325;2374:3;2362:9;2353:7;2349:23;2345:33;2342:120;;;2381:79;;:::i;:::-;2342:120;2501:1;2526:53;2571:7;2562:6;2551:9;2547:22;2526:53;:::i;:::-;2516:63;;2472:117;2628:2;2654:53;2699:7;2690:6;2679:9;2675:22;2654:53;:::i;:::-;2644:63;;2599:118;2756:2;2782:53;2827:7;2818:6;2807:9;2803:22;2782:53;:::i;:::-;2772:63;;2727:118;2884:2;2910:53;2955:7;2946:6;2935:9;2931:22;2910:53;:::i;:::-;2900:63;;2855:118;3012:3;3039:51;3082:7;3073:6;3062:9;3058:22;3039:51;:::i;:::-;3029:61;;2983:117;3139:3;3166:53;3211:7;3202:6;3191:9;3187:22;3166:53;:::i;:::-;3156:63;;3110:119;3268:3;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3239:119;2166:1199;;;;;;;;;;:::o;3371:474::-;3439:6;3447;3496:2;3484:9;3475:7;3471:23;3467:32;3464:119;;;3502:79;;:::i;:::-;3464:119;3622:1;3647:53;3692:7;3683:6;3672:9;3668:22;3647:53;:::i;:::-;3637:63;;3593:117;3749:2;3775:53;3820:7;3811:6;3800:9;3796:22;3775:53;:::i;:::-;3765:63;;3720:118;3371:474;;;;;:::o;3851:1053::-;3953:6;3961;3969;3977;3985;3993;4042:3;4030:9;4021:7;4017:23;4013:33;4010:120;;;4049:79;;:::i;:::-;4010:120;4169:1;4194:53;4239:7;4230:6;4219:9;4215:22;4194:53;:::i;:::-;4184:63;;4140:117;4296:2;4322:53;4367:7;4358:6;4347:9;4343:22;4322:53;:::i;:::-;4312:63;;4267:118;4424:2;4450:53;4495:7;4486:6;4475:9;4471:22;4450:53;:::i;:::-;4440:63;;4395:118;4552:2;4578:51;4621:7;4612:6;4601:9;4597:22;4578:51;:::i;:::-;4568:61;;4523:116;4678:3;4705:53;4750:7;4741:6;4730:9;4726:22;4705:53;:::i;:::-;4695:63;;4649:119;4807:3;4834:53;4879:7;4870:6;4859:9;4855:22;4834:53;:::i;:::-;4824:63;;4778:119;3851:1053;;;;;;;;:::o;4910:472::-;4977:6;4985;5034:2;5022:9;5013:7;5009:23;5005:32;5002:119;;;5040:79;;:::i;:::-;5002:119;5160:1;5185:53;5230:7;5221:6;5210:9;5206:22;5185:53;:::i;:::-;5175:63;;5131:117;5287:2;5313:52;5357:7;5348:6;5337:9;5333:22;5313:52;:::i;:::-;5303:62;;5258:117;4910:472;;;;;:::o;5388:329::-;5447:6;5496:2;5484:9;5475:7;5471:23;5467:32;5464:119;;;5502:79;;:::i;:::-;5464:119;5622:1;5647:53;5692:7;5683:6;5672:9;5668:22;5647:53;:::i;:::-;5637:63;;5593:117;5388:329;;;;:::o;5723:118::-;5810:24;5828:5;5810:24;:::i;:::-;5805:3;5798:37;5723:118;;:::o;5847:109::-;5928:21;5943:5;5928:21;:::i;:::-;5923:3;5916:34;5847:109;;:::o;5962:118::-;6049:24;6067:5;6049:24;:::i;:::-;6044:3;6037:37;5962:118;;:::o;6086:157::-;6191:45;6211:24;6229:5;6211:24;:::i;:::-;6191:45;:::i;:::-;6186:3;6179:58;6086:157;;:::o;6249:364::-;6337:3;6365:39;6398:5;6365:39;:::i;:::-;6420:71;6484:6;6479:3;6420:71;:::i;:::-;6413:78;;6500:52;6545:6;6540:3;6533:4;6526:5;6522:16;6500:52;:::i;:::-;6577:29;6599:6;6577:29;:::i;:::-;6572:3;6568:39;6561:46;;6341:272;6249:364;;;;:::o;6619:366::-;6761:3;6782:67;6846:2;6841:3;6782:67;:::i;:::-;6775:74;;6858:93;6947:3;6858:93;:::i;:::-;6976:2;6971:3;6967:12;6960:19;;6619:366;;;:::o;6991:::-;7133:3;7154:67;7218:2;7213:3;7154:67;:::i;:::-;7147:74;;7230:93;7319:3;7230:93;:::i;:::-;7348:2;7343:3;7339:12;7332:19;;6991:366;;;:::o;7363:::-;7505:3;7526:67;7590:2;7585:3;7526:67;:::i;:::-;7519:74;;7602:93;7691:3;7602:93;:::i;:::-;7720:2;7715:3;7711:12;7704:19;;7363:366;;;:::o;7735:::-;7877:3;7898:67;7962:2;7957:3;7898:67;:::i;:::-;7891:74;;7974:93;8063:3;7974:93;:::i;:::-;8092:2;8087:3;8083:12;8076:19;;7735:366;;;:::o;8107:::-;8249:3;8270:67;8334:2;8329:3;8270:67;:::i;:::-;8263:74;;8346:93;8435:3;8346:93;:::i;:::-;8464:2;8459:3;8455:12;8448:19;;8107:366;;;:::o;8479:::-;8621:3;8642:67;8706:2;8701:3;8642:67;:::i;:::-;8635:74;;8718:93;8807:3;8718:93;:::i;:::-;8836:2;8831:3;8827:12;8820:19;;8479:366;;;:::o;8851:::-;8993:3;9014:67;9078:2;9073:3;9014:67;:::i;:::-;9007:74;;9090:93;9179:3;9090:93;:::i;:::-;9208:2;9203:3;9199:12;9192:19;;8851:366;;;:::o;9223:::-;9365:3;9386:67;9450:2;9445:3;9386:67;:::i;:::-;9379:74;;9462:93;9551:3;9462:93;:::i;:::-;9580:2;9575:3;9571:12;9564:19;;9223:366;;;:::o;9595:::-;9737:3;9758:67;9822:2;9817:3;9758:67;:::i;:::-;9751:74;;9834:93;9923:3;9834:93;:::i;:::-;9952:2;9947:3;9943:12;9936:19;;9595:366;;;:::o;9967:400::-;10127:3;10148:84;10230:1;10225:3;10148:84;:::i;:::-;10141:91;;10241:93;10330:3;10241:93;:::i;:::-;10359:1;10354:3;10350:11;10343:18;;9967:400;;;:::o;10373:366::-;10515:3;10536:67;10600:2;10595:3;10536:67;:::i;:::-;10529:74;;10612:93;10701:3;10612:93;:::i;:::-;10730:2;10725:3;10721:12;10714:19;;10373:366;;;:::o;10745:::-;10887:3;10908:67;10972:2;10967:3;10908:67;:::i;:::-;10901:74;;10984:93;11073:3;10984:93;:::i;:::-;11102:2;11097:3;11093:12;11086:19;;10745:366;;;:::o;11117:::-;11259:3;11280:67;11344:2;11339:3;11280:67;:::i;:::-;11273:74;;11356:93;11445:3;11356:93;:::i;:::-;11474:2;11469:3;11465:12;11458:19;;11117:366;;;:::o;11489:::-;11631:3;11652:67;11716:2;11711:3;11652:67;:::i;:::-;11645:74;;11728:93;11817:3;11728:93;:::i;:::-;11846:2;11841:3;11837:12;11830:19;;11489:366;;;:::o;11861:::-;12003:3;12024:67;12088:2;12083:3;12024:67;:::i;:::-;12017:74;;12100:93;12189:3;12100:93;:::i;:::-;12218:2;12213:3;12209:12;12202:19;;11861:366;;;:::o;12233:::-;12375:3;12396:67;12460:2;12455:3;12396:67;:::i;:::-;12389:74;;12472:93;12561:3;12472:93;:::i;:::-;12590:2;12585:3;12581:12;12574:19;;12233:366;;;:::o;12605:::-;12747:3;12768:67;12832:2;12827:3;12768:67;:::i;:::-;12761:74;;12844:93;12933:3;12844:93;:::i;:::-;12962:2;12957:3;12953:12;12946:19;;12605:366;;;:::o;12977:::-;13119:3;13140:67;13204:2;13199:3;13140:67;:::i;:::-;13133:74;;13216:93;13305:3;13216:93;:::i;:::-;13334:2;13329:3;13325:12;13318:19;;12977:366;;;:::o;13349:::-;13491:3;13512:67;13576:2;13571:3;13512:67;:::i;:::-;13505:74;;13588:93;13677:3;13588:93;:::i;:::-;13706:2;13701:3;13697:12;13690:19;;13349:366;;;:::o;13721:::-;13863:3;13884:67;13948:2;13943:3;13884:67;:::i;:::-;13877:74;;13960:93;14049:3;13960:93;:::i;:::-;14078:2;14073:3;14069:12;14062:19;;13721:366;;;:::o;14093:::-;14235:3;14256:67;14320:2;14315:3;14256:67;:::i;:::-;14249:74;;14332:93;14421:3;14332:93;:::i;:::-;14450:2;14445:3;14441:12;14434:19;;14093:366;;;:::o;14465:::-;14607:3;14628:67;14692:2;14687:3;14628:67;:::i;:::-;14621:74;;14704:93;14793:3;14704:93;:::i;:::-;14822:2;14817:3;14813:12;14806:19;;14465:366;;;:::o;14837:::-;14979:3;15000:67;15064:2;15059:3;15000:67;:::i;:::-;14993:74;;15076:93;15165:3;15076:93;:::i;:::-;15194:2;15189:3;15185:12;15178:19;;14837:366;;;:::o;15277:517::-;15430:4;15425:3;15421:14;15522:4;15515:5;15511:16;15505:23;15541:61;15596:4;15591:3;15587:14;15573:12;15541:61;:::i;:::-;15445:167;15695:4;15688:5;15684:16;15678:23;15714:63;15771:4;15766:3;15762:14;15748:12;15714:63;:::i;:::-;15622:165;15399:395;15277:517;;:::o;15800:108::-;15877:24;15895:5;15877:24;:::i;:::-;15872:3;15865:37;15800:108;;:::o;15914:118::-;16001:24;16019:5;16001:24;:::i;:::-;15996:3;15989:37;15914:118;;:::o;16038:105::-;16113:23;16130:5;16113:23;:::i;:::-;16108:3;16101:36;16038:105;;:::o;16149:115::-;16234:23;16251:5;16234:23;:::i;:::-;16229:3;16222:36;16149:115;;:::o;16270:112::-;16353:22;16369:5;16353:22;:::i;:::-;16348:3;16341:35;16270:112;;:::o;16388:663::-;16629:3;16651:148;16795:3;16651:148;:::i;:::-;16644:155;;16809:75;16880:3;16871:6;16809:75;:::i;:::-;16909:2;16904:3;16900:12;16893:19;;16922:75;16993:3;16984:6;16922:75;:::i;:::-;17022:2;17017:3;17013:12;17006:19;;17042:3;17035:10;;16388:663;;;;;:::o;17057:222::-;17150:4;17188:2;17177:9;17173:18;17165:26;;17201:71;17269:1;17258:9;17254:17;17245:6;17201:71;:::i;:::-;17057:222;;;;:::o;17285:210::-;17372:4;17410:2;17399:9;17395:18;17387:26;;17423:65;17485:1;17474:9;17470:17;17461:6;17423:65;:::i;:::-;17285:210;;;;:::o;17501:222::-;17594:4;17632:2;17621:9;17617:18;17609:26;;17645:71;17713:1;17702:9;17698:17;17689:6;17645:71;:::i;:::-;17501:222;;;;:::o;17729:775::-;17962:4;18000:3;17989:9;17985:19;17977:27;;18014:71;18082:1;18071:9;18067:17;18058:6;18014:71;:::i;:::-;18095:72;18163:2;18152:9;18148:18;18139:6;18095:72;:::i;:::-;18177;18245:2;18234:9;18230:18;18221:6;18177:72;:::i;:::-;18259;18327:2;18316:9;18312:18;18303:6;18259:72;:::i;:::-;18341:73;18409:3;18398:9;18394:19;18385:6;18341:73;:::i;:::-;18424;18492:3;18481:9;18477:19;18468:6;18424:73;:::i;:::-;17729:775;;;;;;;;;:::o;18510:553::-;18687:4;18725:3;18714:9;18710:19;18702:27;;18739:71;18807:1;18796:9;18792:17;18783:6;18739:71;:::i;:::-;18820:72;18888:2;18877:9;18873:18;18864:6;18820:72;:::i;:::-;18902;18970:2;18959:9;18955:18;18946:6;18902:72;:::i;:::-;18984;19052:2;19041:9;19037:18;19028:6;18984:72;:::i;:::-;18510:553;;;;;;;:::o;19069:664::-;19274:4;19312:3;19301:9;19297:19;19289:27;;19326:71;19394:1;19383:9;19379:17;19370:6;19326:71;:::i;:::-;19407:72;19475:2;19464:9;19460:18;19451:6;19407:72;:::i;:::-;19489;19557:2;19546:9;19542:18;19533:6;19489:72;:::i;:::-;19571;19639:2;19628:9;19624:18;19615:6;19571:72;:::i;:::-;19653:73;19721:3;19710:9;19706:19;19697:6;19653:73;:::i;:::-;19069:664;;;;;;;;:::o;19739:545::-;19912:4;19950:3;19939:9;19935:19;19927:27;;19964:71;20032:1;20021:9;20017:17;20008:6;19964:71;:::i;:::-;20045:68;20109:2;20098:9;20094:18;20085:6;20045:68;:::i;:::-;20123:72;20191:2;20180:9;20176:18;20167:6;20123:72;:::i;:::-;20205;20273:2;20262:9;20258:18;20249:6;20205:72;:::i;:::-;19739:545;;;;;;;:::o;20290:313::-;20403:4;20441:2;20430:9;20426:18;20418:26;;20490:9;20484:4;20480:20;20476:1;20465:9;20461:17;20454:47;20518:78;20591:4;20582:6;20518:78;:::i;:::-;20510:86;;20290:313;;;;:::o;20609:419::-;20775:4;20813:2;20802:9;20798:18;20790:26;;20862:9;20856:4;20852:20;20848:1;20837:9;20833:17;20826:47;20890:131;21016:4;20890:131;:::i;:::-;20882:139;;20609:419;;;:::o;21034:::-;21200:4;21238:2;21227:9;21223:18;21215:26;;21287:9;21281:4;21277:20;21273:1;21262:9;21258:17;21251:47;21315:131;21441:4;21315:131;:::i;:::-;21307:139;;21034:419;;;:::o;21459:::-;21625:4;21663:2;21652:9;21648:18;21640:26;;21712:9;21706:4;21702:20;21698:1;21687:9;21683:17;21676:47;21740:131;21866:4;21740:131;:::i;:::-;21732:139;;21459:419;;;:::o;21884:::-;22050:4;22088:2;22077:9;22073:18;22065:26;;22137:9;22131:4;22127:20;22123:1;22112:9;22108:17;22101:47;22165:131;22291:4;22165:131;:::i;:::-;22157:139;;21884:419;;;:::o;22309:::-;22475:4;22513:2;22502:9;22498:18;22490:26;;22562:9;22556:4;22552:20;22548:1;22537:9;22533:17;22526:47;22590:131;22716:4;22590:131;:::i;:::-;22582:139;;22309:419;;;:::o;22734:::-;22900:4;22938:2;22927:9;22923:18;22915:26;;22987:9;22981:4;22977:20;22973:1;22962:9;22958:17;22951:47;23015:131;23141:4;23015:131;:::i;:::-;23007:139;;22734:419;;;:::o;23159:::-;23325:4;23363:2;23352:9;23348:18;23340:26;;23412:9;23406:4;23402:20;23398:1;23387:9;23383:17;23376:47;23440:131;23566:4;23440:131;:::i;:::-;23432:139;;23159:419;;;:::o;23584:::-;23750:4;23788:2;23777:9;23773:18;23765:26;;23837:9;23831:4;23827:20;23823:1;23812:9;23808:17;23801:47;23865:131;23991:4;23865:131;:::i;:::-;23857:139;;23584:419;;;:::o;24009:::-;24175:4;24213:2;24202:9;24198:18;24190:26;;24262:9;24256:4;24252:20;24248:1;24237:9;24233:17;24226:47;24290:131;24416:4;24290:131;:::i;:::-;24282:139;;24009:419;;;:::o;24434:::-;24600:4;24638:2;24627:9;24623:18;24615:26;;24687:9;24681:4;24677:20;24673:1;24662:9;24658:17;24651:47;24715:131;24841:4;24715:131;:::i;:::-;24707:139;;24434:419;;;:::o;24859:::-;25025:4;25063:2;25052:9;25048:18;25040:26;;25112:9;25106:4;25102:20;25098:1;25087:9;25083:17;25076:47;25140:131;25266:4;25140:131;:::i;:::-;25132:139;;24859:419;;;:::o;25284:::-;25450:4;25488:2;25477:9;25473:18;25465:26;;25537:9;25531:4;25527:20;25523:1;25512:9;25508:17;25501:47;25565:131;25691:4;25565:131;:::i;:::-;25557:139;;25284:419;;;:::o;25709:::-;25875:4;25913:2;25902:9;25898:18;25890:26;;25962:9;25956:4;25952:20;25948:1;25937:9;25933:17;25926:47;25990:131;26116:4;25990:131;:::i;:::-;25982:139;;25709:419;;;:::o;26134:::-;26300:4;26338:2;26327:9;26323:18;26315:26;;26387:9;26381:4;26377:20;26373:1;26362:9;26358:17;26351:47;26415:131;26541:4;26415:131;:::i;:::-;26407:139;;26134:419;;;:::o;26559:::-;26725:4;26763:2;26752:9;26748:18;26740:26;;26812:9;26806:4;26802:20;26798:1;26787:9;26783:17;26776:47;26840:131;26966:4;26840:131;:::i;:::-;26832:139;;26559:419;;;:::o;26984:::-;27150:4;27188:2;27177:9;27173:18;27165:26;;27237:9;27231:4;27227:20;27223:1;27212:9;27208:17;27201:47;27265:131;27391:4;27265:131;:::i;:::-;27257:139;;26984:419;;;:::o;27409:::-;27575:4;27613:2;27602:9;27598:18;27590:26;;27662:9;27656:4;27652:20;27648:1;27637:9;27633:17;27626:47;27690:131;27816:4;27690:131;:::i;:::-;27682:139;;27409:419;;;:::o;27834:::-;28000:4;28038:2;28027:9;28023:18;28015:26;;28087:9;28081:4;28077:20;28073:1;28062:9;28058:17;28051:47;28115:131;28241:4;28115:131;:::i;:::-;28107:139;;27834:419;;;:::o;28259:::-;28425:4;28463:2;28452:9;28448:18;28440:26;;28512:9;28506:4;28502:20;28498:1;28487:9;28483:17;28476:47;28540:131;28666:4;28540:131;:::i;:::-;28532:139;;28259:419;;;:::o;28684:::-;28850:4;28888:2;28877:9;28873:18;28865:26;;28937:9;28931:4;28927:20;28923:1;28912:9;28908:17;28901:47;28965:131;29091:4;28965:131;:::i;:::-;28957:139;;28684:419;;;:::o;29109:::-;29275:4;29313:2;29302:9;29298:18;29290:26;;29362:9;29356:4;29352:20;29348:1;29337:9;29333:17;29326:47;29390:131;29516:4;29390:131;:::i;:::-;29382:139;;29109:419;;;:::o;29534:::-;29700:4;29738:2;29727:9;29723:18;29715:26;;29787:9;29781:4;29777:20;29773:1;29762:9;29758:17;29751:47;29815:131;29941:4;29815:131;:::i;:::-;29807:139;;29534:419;;;:::o;29959:334::-;30108:4;30146:2;30135:9;30131:18;30123:26;;30159:127;30283:1;30272:9;30268:17;30259:6;30159:127;:::i;:::-;29959:334;;;;:::o;30299:222::-;30392:4;30430:2;30419:9;30415:18;30407:26;;30443:71;30511:1;30500:9;30496:17;30487:6;30443:71;:::i;:::-;30299:222;;;;:::o;30527:332::-;30648:4;30686:2;30675:9;30671:18;30663:26;;30699:71;30767:1;30756:9;30752:17;30743:6;30699:71;:::i;:::-;30780:72;30848:2;30837:9;30833:18;30824:6;30780:72;:::i;:::-;30527:332;;;;;:::o;30865:218::-;30956:4;30994:2;30983:9;30979:18;30971:26;;31007:69;31073:1;31062:9;31058:17;31049:6;31007:69;:::i;:::-;30865:218;;;;:::o;31089:214::-;31178:4;31216:2;31205:9;31201:18;31193:26;;31229:67;31293:1;31282:9;31278:17;31269:6;31229:67;:::i;:::-;31089:214;;;;:::o;31390:99::-;31442:6;31476:5;31470:12;31460:22;;31390:99;;;:::o;31495:169::-;31579:11;31613:6;31608:3;31601:19;31653:4;31648:3;31644:14;31629:29;;31495:169;;;;:::o;31670:148::-;31772:11;31809:3;31794:18;;31670:148;;;;:::o;31824:305::-;31864:3;31883:20;31901:1;31883:20;:::i;:::-;31878:25;;31917:20;31935:1;31917:20;:::i;:::-;31912:25;;32071:1;32003:66;31999:74;31996:1;31993:81;31990:107;;;32077:18;;:::i;:::-;31990:107;32121:1;32118;32114:9;32107:16;;31824:305;;;;:::o;32135:185::-;32175:1;32192:20;32210:1;32192:20;:::i;:::-;32187:25;;32226:20;32244:1;32226:20;:::i;:::-;32221:25;;32265:1;32255:35;;32270:18;;:::i;:::-;32255:35;32312:1;32309;32305:9;32300:14;;32135:185;;;;:::o;32326:191::-;32366:4;32386:20;32404:1;32386:20;:::i;:::-;32381:25;;32420:20;32438:1;32420:20;:::i;:::-;32415:25;;32459:1;32456;32453:8;32450:34;;;32464:18;;:::i;:::-;32450:34;32509:1;32506;32502:9;32494:17;;32326:191;;;;:::o;32523:96::-;32560:7;32589:24;32607:5;32589:24;:::i;:::-;32578:35;;32523:96;;;:::o;32625:90::-;32659:7;32702:5;32695:13;32688:21;32677:32;;32625:90;;;:::o;32721:77::-;32758:7;32787:5;32776:16;;32721:77;;;:::o;32804:126::-;32841:7;32881:42;32874:5;32870:54;32859:65;;32804:126;;;:::o;32936:142::-;32973:7;33013:58;33006:5;33002:70;32991:81;;32936:142;;;:::o;33084:77::-;33121:7;33150:5;33139:16;;33084:77;;;:::o;33167:93::-;33203:7;33243:10;33236:5;33232:22;33221:33;;33167:93;;;:::o;33266:86::-;33301:7;33341:4;33334:5;33330:16;33319:27;;33266:86;;;:::o;33358:307::-;33426:1;33436:113;33450:6;33447:1;33444:13;33436:113;;;33535:1;33530:3;33526:11;33520:18;33516:1;33511:3;33507:11;33500:39;33472:2;33469:1;33465:10;33460:15;;33436:113;;;33567:6;33564:1;33561:13;33558:101;;;33647:1;33638:6;33633:3;33629:16;33622:27;33558:101;33407:258;33358:307;;;:::o;33671:320::-;33715:6;33752:1;33746:4;33742:12;33732:22;;33799:1;33793:4;33789:12;33820:18;33810:81;;33876:4;33868:6;33864:17;33854:27;;33810:81;33938:2;33930:6;33927:14;33907:18;33904:38;33901:84;;;33957:18;;:::i;:::-;33901:84;33722:269;33671:320;;;:::o;33997:79::-;34036:7;34065:5;34054:16;;33997:79;;;:::o;34082:180::-;34130:77;34127:1;34120:88;34227:4;34224:1;34217:15;34251:4;34248:1;34241:15;34268:180;34316:77;34313:1;34306:88;34413:4;34410:1;34403:15;34437:4;34434:1;34427:15;34454:180;34502:77;34499:1;34492:88;34599:4;34596:1;34589:15;34623:4;34620:1;34613:15;34640:180;34688:77;34685:1;34678:88;34785:4;34782:1;34775:15;34809:4;34806:1;34799:15;34826:180;34874:77;34871:1;34864:88;34971:4;34968:1;34961:15;34995:4;34992:1;34985:15;35135:117;35244:1;35241;35234:12;35258:102;35299:6;35350:2;35346:7;35341:2;35334:5;35330:14;35326:28;35316:38;;35258:102;;;:::o;35366:174::-;35506:26;35502:1;35494:6;35490:14;35483:50;35366:174;:::o;35546:222::-;35686:34;35682:1;35674:6;35670:14;35663:58;35755:5;35750:2;35742:6;35738:15;35731:30;35546:222;:::o;35774:181::-;35914:33;35910:1;35902:6;35898:14;35891:57;35774:181;:::o;35961:179::-;36101:31;36097:1;36089:6;36085:14;36078:55;35961:179;:::o;36146:221::-;36286:34;36282:1;36274:6;36270:14;36263:58;36355:4;36350:2;36342:6;36338:15;36331:29;36146:221;:::o;36373:181::-;36513:33;36509:1;36501:6;36497:14;36490:57;36373:181;:::o;36560:175::-;36700:27;36696:1;36688:6;36684:14;36677:51;36560:175;:::o;36741:225::-;36881:34;36877:1;36869:6;36865:14;36858:58;36950:8;36945:2;36937:6;36933:15;36926:33;36741:225;:::o;36972:221::-;37112:34;37108:1;37100:6;37096:14;37089:58;37181:4;37176:2;37168:6;37164:15;37157:29;36972:221;:::o;37199:214::-;37339:66;37335:1;37327:6;37323:14;37316:90;37199:214;:::o;37419:179::-;37559:31;37555:1;37547:6;37543:14;37536:55;37419:179;:::o;37604:::-;37744:31;37740:1;37732:6;37728:14;37721:55;37604:179;:::o;37789:225::-;37929:34;37925:1;37917:6;37913:14;37906:58;37998:8;37993:2;37985:6;37981:15;37974:33;37789:225;:::o;38020:221::-;38160:34;38156:1;38148:6;38144:14;38137:58;38229:4;38224:2;38216:6;38212:15;38205:29;38020:221;:::o;38247:::-;38387:34;38383:1;38375:6;38371:14;38364:58;38456:4;38451:2;38443:6;38439:15;38432:29;38247:221;:::o;38474:180::-;38614:32;38610:1;38602:6;38598:14;38591:56;38474:180;:::o;38660:182::-;38800:34;38796:1;38788:6;38784:14;38777:58;38660:182;:::o;38848:226::-;38988:34;38984:1;38976:6;38972:14;38965:58;39057:9;39052:2;39044:6;39040:15;39033:34;38848:226;:::o;39080:220::-;39220:34;39216:1;39208:6;39204:14;39197:58;39289:3;39284:2;39276:6;39272:15;39265:28;39080:220;:::o;39306:224::-;39446:34;39442:1;39434:6;39430:14;39423:58;39515:7;39510:2;39502:6;39498:15;39491:32;39306:224;:::o;39536:225::-;39676:34;39672:1;39664:6;39660:14;39653:58;39745:8;39740:2;39732:6;39728:15;39721:33;39536:225;:::o;39767:223::-;39907:34;39903:1;39895:6;39891:14;39884:58;39976:6;39971:2;39963:6;39959:15;39952:31;39767:223;:::o;39996:224::-;40136:34;40132:1;40124:6;40120:14;40113:58;40205:7;40200:2;40192:6;40188:15;40181:32;39996:224;:::o;40226:122::-;40299:24;40317:5;40299:24;:::i;:::-;40292:5;40289:35;40279:63;;40338:1;40335;40328:12;40279:63;40226:122;:::o;40354:::-;40427:24;40445:5;40427:24;:::i;:::-;40420:5;40417:35;40407:63;;40466:1;40463;40456:12;40407:63;40354:122;:::o;40482:::-;40555:24;40573:5;40555:24;:::i;:::-;40548:5;40545:35;40535:63;;40594:1;40591;40584:12;40535:63;40482:122;:::o;40610:120::-;40682:23;40699:5;40682:23;:::i;:::-;40675:5;40672:34;40662:62;;40720:1;40717;40710:12;40662:62;40610:120;:::o;40736:118::-;40807:22;40823:5;40807:22;:::i;:::-;40800:5;40797:33;40787:61;;40844:1;40841;40834:12;40787:61;40736:118;:::o
Swarm Source
ipfs://a692a7169c1b76e00977e7471267421de7dd733fbfca72e6d580b6a33951a015
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.