ERC-20
Overview
Max Total Supply
1,000,000,000,000,000 INT
Holders
18,362
Market
Price
$0.00 @ 0.000000 MATIC
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
InternetToken
Compiler Version
v0.8.6+commit.11564f7e
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.2; import "ERC20.sol"; import "ERC20Burnable.sol"; import "ERC20Snapshot.sol"; import "Ownable.sol"; import "Pausable.sol"; import "draft-ERC20Permit.sol"; import "ERC20Votes.sol"; contract InternetToken is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes { constructor() ERC20("Internet Token", "INT") ERC20Permit("Internet Token") { _mint(msg.sender, 1000000000000000 * 10 ** decimals()); } function snapshot() public onlyOwner { _snapshot(); } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); } function mint(address to, uint256 amount) public onlyOwner { _mint(to, amount); } function _beforeTokenTransfer(address from, address to, uint256 amount) internal whenNotPaused override(ERC20, ERC20Snapshot) { super._beforeTokenTransfer(from, to, amount); } function _afterTokenTransfer(address from, address to, uint256 amount) internal override(ERC20, ERC20Votes) { super._afterTokenTransfer(from, to, amount); } function _mint(address to, uint256 amount) internal override(ERC20, ERC20Votes) { super._mint(to, amount); } function _burn(address account, uint256 amount) internal override(ERC20, ERC20Votes) { super._burn(account, amount); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "Math.sol"; /** * @dev Collection of functions related to array types. */ library Arrays { /** * @dev Searches a sorted `array` and returns the first index that contains * a value greater or equal to `element`. If no such index exists (i.e. all * values in the array are strictly less than `element`), the array length is * returned. Time complexity O(log n). * * `array` is expected to be sorted in ascending order, and to contain no * repeated elements. */ function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { if (array.length == 0) { return 0; } uint256 low = 0; uint256 high = array.length; while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds down (it does integer division with truncation). if (array[mid] > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && array[low - 1] == element) { return low - 1; } else { return low; } } }
// SPDX-License-Identifier: MIT 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; } }
// SPDX-License-Identifier: MIT 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; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "ECDSA.sol"; /** * @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; 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); _TYPE_HASH = typeHash; } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (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); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "draft-IERC20Permit.sol"; import "ERC20.sol"; import "draft-EIP712.sol"; import "ECDSA.sol"; import "Counters.sol"; /** * @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 immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /** * @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(); } }
// SPDX-License-Identifier: MIT 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); }
// SPDX-License-Identifier: MIT 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 { /** * @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. * * 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] */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // 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 recover(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 recover(hash, r, vs); } else { revert("ECDSA: invalid signature length"); } } /** * @dev Overload of {ECDSA-recover} 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.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { bytes32 s; uint8 v; assembly { s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) v := add(shr(255, vs), 27) } return recover(hash, v, r, s); } /** * @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) { // 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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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. require( uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value" ); require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value"); // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); require(signer != address(0), "ECDSA: invalid signature"); return signer; } /** * @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 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)); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IERC20.sol"; import "IERC20Metadata.sol"; import "Context.sol"; /** * @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 guidelines: functions revert instead * of 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) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _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: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, 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}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), 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}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - 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) { _approve(_msgSender(), spender, _allowances[_msgSender()][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) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), 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: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, 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 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 {} }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "ERC20.sol"; import "Context.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 currentAllowance = allowance(account, _msgSender()); require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance"); unchecked { _approve(account, _msgSender(), currentAllowance - amount); } _burn(account, amount); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "ERC20.sol"; import "Arrays.sol"; import "Counters.sol"; /** * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and * total supply at the time are recorded for later access. * * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting. * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be * used to create an efficient ERC20 forking mechanism. * * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id * and the account address. * * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it * return `block.number` will trigger the creation of snapshot at the begining of each new block. When overridding this * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract. * * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient * alternative consider {ERC20Votes}. * * ==== Gas Costs * * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much * smaller since identical balances in subsequent snapshots are stored as a single entry. * * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent * transfers will have normal cost until the next snapshot, and so on. */ abstract contract ERC20Snapshot is ERC20 { // Inspired by Jordi Baylina's MiniMeToken to record historical balances: // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol using Arrays for uint256[]; using Counters for Counters.Counter; // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a // Snapshot struct, but that would impede usage of functions that work on an array. struct Snapshots { uint256[] ids; uint256[] values; } mapping(address => Snapshots) private _accountBalanceSnapshots; Snapshots private _totalSupplySnapshots; // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid. Counters.Counter private _currentSnapshotId; /** * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created. */ event Snapshot(uint256 id); /** * @dev Creates a new snapshot and returns its snapshot id. * * Emits a {Snapshot} event that contains the same id. * * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a * set of accounts, for example using {AccessControl}, or it may be open to the public. * * [WARNING] * ==== * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking, * you must consider that it can potentially be used by attackers in two ways. * * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs * section above. * * We haven't measured the actual numbers; if this is something you're interested in please reach out to us. * ==== */ function _snapshot() internal virtual returns (uint256) { _currentSnapshotId.increment(); uint256 currentId = _getCurrentSnapshotId(); emit Snapshot(currentId); return currentId; } /** * @dev Get the current snapshotId */ function _getCurrentSnapshotId() internal view virtual returns (uint256) { return _currentSnapshotId.current(); } /** * @dev Retrieves the balance of `account` at the time `snapshotId` was created. */ function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) { (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]); return snapshotted ? value : balanceOf(account); } /** * @dev Retrieves the total supply at the time `snapshotId` was created. */ function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) { (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots); return snapshotted ? value : totalSupply(); } // Update balance and/or total supply snapshots before the values are modified. This is implemented // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations. function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._beforeTokenTransfer(from, to, amount); if (from == address(0)) { // mint _updateAccountSnapshot(to); _updateTotalSupplySnapshot(); } else if (to == address(0)) { // burn _updateAccountSnapshot(from); _updateTotalSupplySnapshot(); } else { // transfer _updateAccountSnapshot(from); _updateAccountSnapshot(to); } } function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) { require(snapshotId > 0, "ERC20Snapshot: id is 0"); require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id"); // When a valid snapshot is queried, there are three possibilities: // a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never // created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds // to this id is the current one. // b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the // requested id, and its value is the one to return. // c) More snapshots were created after the requested one, and the queried value was later modified. There will be // no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is // larger than the requested one. // // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does // exactly this. uint256 index = snapshots.ids.findUpperBound(snapshotId); if (index == snapshots.ids.length) { return (false, 0); } else { return (true, snapshots.values[index]); } } function _updateAccountSnapshot(address account) private { _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account)); } function _updateTotalSupplySnapshot() private { _updateSnapshot(_totalSupplySnapshots, totalSupply()); } function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private { uint256 currentId = _getCurrentSnapshotId(); if (_lastSnapshotId(snapshots.ids) < currentId) { snapshots.ids.push(currentId); snapshots.values.push(currentValue); } } function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) { if (ids.length == 0) { return 0; } else { return ids[ids.length - 1]; } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "draft-ERC20Permit.sol"; import "Math.sol"; import "SafeCast.sol"; import "ECDSA.sol"; /** * @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. * Enabling self-delegation can easily be done by overriding the {delegates} function. Keep in mind however that this * will significantly increase the base gas cost of transfers. * * _Available since v4.2._ */ abstract contract ERC20Votes is 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 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 an account's voting power. */ event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance); /** * @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 returns (address) { return _delegates[account]; } /** * @dev Gets the current votes balance for `account` */ function getVotes(address account) public view 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 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 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, 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 `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 { return _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 { 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"); return _delegate(signer, delegatee); } /** * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1). */ function _maxSupply() internal view virtual returns (uint224) { return type(uint224).max; } /** * @dev Snapshots the totalSupply after it has been increased. */ function _mint(address account, uint256 amount) internal virtual override { super._mint(account, amount); require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes"); _writeCheckpoint(_totalSupplyCheckpoints, _add, amount); } /** * @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; } }
// SPDX-License-Identifier: MIT 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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, 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); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "IERC20.sol"; /** * @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); }
// SPDX-License-Identifier: MIT 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, so we distribute. return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 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); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract 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() { _setOwner(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _setOwner(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
// SPDX-License-Identifier: MIT 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); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","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":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"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":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"snapshot","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","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"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
236:1281:17:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2047:98:4;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4144:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3135:106;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4777:478;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2984:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2350:113:15;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5650:212:4;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3186:248:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;636:63:17;;;:::i;:::-;;705:93;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;469:89:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4874:262:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2605:117:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5561:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1032:84:12;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2368:149:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3299:125:4;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1596:92:11;;;:::i;:::-;;864:361:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2100:126:15;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;571:59:17;;;:::i;:::-;;964:85:11;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3713:239:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2258:102:4;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;500:65:17;;;:::i;:::-;;5235:230:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2801:192:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6349:405:4;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3627:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5748:572:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1413:626:15;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3857:149:4;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2145:148:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1837:189:11;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2047:98:4;2101:13;2133:5;2126:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2047:98;:::o;4144:166::-;4227:4;4243:39;4252:12;:10;:12::i;:::-;4266:7;4275:6;4243:8;:39::i;:::-;4299:4;4292:11;;4144:166;;;;:::o;3135:106::-;3196:7;3222:12;;3215:19;;3135:106;:::o;4777:478::-;4913:4;4929:36;4939:6;4947:9;4958:6;4929:9;:36::i;:::-;4976:24;5003:11;:19;5015:6;5003:19;;;;;;;;;;;;;;;:33;5023:12;:10;:12::i;:::-;5003:33;;;;;;;;;;;;;;;;4976:60;;5074:6;5054:16;:26;;5046:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;5159:57;5168:6;5176:12;:10;:12::i;:::-;5209:6;5190:16;:25;5159:8;:57::i;:::-;5244:4;5237:11;;;4777:478;;;;;:::o;2984:91::-;3042:5;3066:2;3059:9;;2984:91;:::o;2350:113:15:-;2410:7;2436:20;:18;:20::i;:::-;2429:27;;2350:113;:::o;5650:212:4:-;5738:4;5754:80;5763:12;:10;:12::i;:::-;5777:7;5823:10;5786:11;:25;5798:12;:10;:12::i;:::-;5786:25;;;;;;;;;;;;;;;:34;5812:7;5786:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5754:8;:80::i;:::-;5851:4;5844:11;;5650:212;;;;:::o;3186:248:7:-;3267:7;3308:12;3294:11;:26;3286:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;3373:54;3392:12;:21;3405:7;3392:21;;;;;;;;;;;;;;;3415:11;3373:18;:54::i;:::-;3366:61;;3186:248;;;;:::o;636:63:17:-;1187:12:11;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;682:10:17::1;:8;:10::i;:::-;636:63::o:0;705:93::-;1187:12:11;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;774:17:17::1;780:2;784:6;774:5;:17::i;:::-;705:93:::0;;:::o;469:89:5:-;524:27;530:12;:10;:12::i;:::-;544:6;524:5;:27::i;:::-;469:89;:::o;4874:262:6:-;4961:7;4981:16;4999:13;5016:55;5025:10;5037:24;:33;5062:7;5037:33;;;;;;;;;;;;;;;5016:8;:55::i;:::-;4980:91;;;;5089:11;:40;;5111:18;5121:7;5111:9;:18::i;:::-;5089:40;;;5103:5;5089:40;5082:47;;;;4874:262;;;;:::o;2605:117:7:-;2670:7;2696:10;:19;2707:7;2696:19;;;;;;;;;;;;;;;;;;;;;;;;;2689:26;;2605:117;;;:::o;5561:110::-;5630:34;5640:12;:10;:12::i;:::-;5654:9;5630;:34::i;:::-;5561:110;:::o;1032:84:12:-;1079:4;1102:7;;;;;;;;;;;1095:14;;1032:84;:::o;2368:149:7:-;2438:6;2463:47;2481:12;:21;2494:7;2481:21;;;;;;;;;;;;;;;:28;;;;2463:17;:47::i;:::-;2456:54;;2368:149;;;:::o;3299:125:4:-;3373:7;3399:9;:18;3409:7;3399:18;;;;;;;;;;;;;;;;3392:25;;3299:125;;;:::o;1596:92:11:-;1187:12;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1660:21:::1;1678:1;1660:9;:21::i;:::-;1596:92::o:0;864:361:5:-;940:24;967:32;977:7;986:12;:10;:12::i;:::-;967:9;:32::i;:::-;940:59;;1037:6;1017:16;:26;;1009:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;1118:58;1127:7;1136:12;:10;:12::i;:::-;1169:6;1150:16;:25;1118:8;:58::i;:::-;1196:22;1202:7;1211:6;1196:5;:22::i;:::-;930:295;864:361;;:::o;2100:126:15:-;2169:7;2195:24;:7;:14;2203:5;2195:14;;;;;;;;;;;;;;;:22;:24::i;:::-;2188:31;;2100:126;;;:::o;571:59:17:-;1187:12:11;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;615:8:17::1;:6;:8::i;:::-;571:59::o:0;964:85:11:-;1010:7;1036:6;;;;;;;;;;;1029:13;;964:85;:::o;3713:239:7:-;3783:7;3824:12;3810:11;:26;3802:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;3889:56;3908:23;3933:11;3889:18;:56::i;:::-;3882:63;;3713:239;;;:::o;2258:102:4:-;2314:13;2346:7;2339:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2258:102;:::o;500:65:17:-;1187:12:11;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;547:11:17::1;:9;:11::i;:::-;;500:65::o:0;5235:230:6:-;5307:7;5327:16;5345:13;5362:43;5371:10;5383:21;5362:8;:43::i;:::-;5326:79;;;;5423:11;:35;;5445:13;:11;:13::i;:::-;5423:35;;;5437:5;5423:35;5416:42;;;;5235:230;;;:::o;2801:192:7:-;2857:7;2876:11;2890:12;:21;2903:7;2890:21;;;;;;;;;;;;;;;:28;;;;2876:42;;2942:1;2935:3;:8;:51;;2950:12;:21;2963:7;2950:21;;;;;;;;;;;;;;;2978:1;2972:3;:7;;;;:::i;:::-;2950:30;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;;;;;;;;;2935:51;;;2946:1;2935:51;2928:58;;;;;2801:192;;;:::o;6349:405:4:-;6442:4;6458:24;6485:11;:25;6497:12;:10;:12::i;:::-;6485:25;;;;;;;;;;;;;;;:34;6511:7;6485:34;;;;;;;;;;;;;;;;6458:61;;6557:15;6537:16;:35;;6529:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;6648:67;6657:12;:10;:12::i;:::-;6671:7;6699:15;6680:16;:34;6648:8;:67::i;:::-;6743:4;6736:11;;;6349:405;;;;:::o;3627:172::-;3713:4;3729:42;3739:12;:10;:12::i;:::-;3753:9;3764:6;3729:9;:42::i;:::-;3788:4;3781:11;;3627:172;;;;:::o;5748:572:7:-;5958:6;5939:15;:25;;5931:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;6008:14;6025:169;6052:87;1415:71;6112:9;6123:5;6130:6;6079:58;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6069:69;;;;;;6052:16;:87::i;:::-;6153:1;6168;6183;6025:13;:169::i;:::-;6008:186;;6221:17;6231:6;6221:9;:17::i;:::-;6212:5;:26;6204:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;6285:28;6295:6;6303:9;6285;:28::i;:::-;6278:35;5748:572;;;;;;:::o;1413:626:15:-;1648:8;1629:15;:27;;1621:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;1701:18;1743:16;1761:5;1768:7;1777:5;1784:16;1794:5;1784:9;:16::i;:::-;1802:8;1732:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1722:90;;;;;;1701:111;;1823:12;1838:28;1855:10;1838:16;:28::i;:::-;1823:43;;1877:14;1894:28;1908:4;1914:1;1917;1920;1894:13;:28::i;:::-;1877:45;;1950:5;1940:15;;:6;:15;;;1932:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;2001:31;2010:5;2017:7;2026:5;2001:8;:31::i;:::-;1611:428;;;1413:626;;;;;;;:::o;3857:149:4:-;3946:7;3972:11;:18;3984:5;3972:18;;;;;;;;;;;;;;;:27;3991:7;3972:27;;;;;;;;;;;;;;;;3965:34;;3857:149;;;;:::o;2145:148:7:-;2224:17;;:::i;:::-;2260:12;:21;2273:7;2260:21;;;;;;;;;;;;;;;2282:3;2260:26;;;;;;;;;;:::i;:::-;;;;;;;;;2253:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2145:148;;;;:::o;1837:189:11:-;1187:12;:10;:12::i;:::-;1176:23;;:7;:5;:7::i;:::-;:23;;;1168:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1945:1:::1;1925:22;;:8;:22;;;;1917:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2000:19;2010:8;2000:9;:19::i;:::-;1837:189:::0;:::o;6614:285:7:-;6698:28;6710:7;6719:6;6698:11;:28::i;:::-;6761:12;:10;:12::i;:::-;6744:29;;:13;:11;:13::i;:::-;:29;;6736:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;6837:55;6854:23;6879:4;6885:6;6837:16;:55::i;:::-;;;6614:285;;:::o;8217:389:4:-;8319:1;8300:21;;:7;:21;;;;8292:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;8368:49;8397:1;8401:7;8410:6;8368:20;:49::i;:::-;8444:6;8428:12;;:22;;;;;;;:::i;:::-;;;;;;;;8482:6;8460:9;:18;8470:7;8460:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;8524:7;8503:37;;8520:1;8503:37;;;8533:6;8503:37;;;;;;:::i;:::-;;;;;;;;8551:48;8579:1;8583:7;8592:6;8551:19;:48::i;:::-;8217:389;;:::o;9378:96:7:-;9436:7;9466:1;9462;:5;;;;:::i;:::-;9455:12;;9378:96;;;;:::o;1076:192:13:-;1133:7;1169:17;1160:26;;:5;:26;;1152:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;1255:5;1240:21;;1076:192;;;:::o;2986:187::-;3042:6;3077:16;3068:25;;:5;:25;;3060:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;3160:5;3146:20;;2986:187;;;:::o;5678:602:6:-;5816:44;5843:4;5849:2;5853:6;5816:26;:44::i;:::-;5891:1;5875:18;;:4;:18;;;5871:403;;;5929:26;5952:2;5929:22;:26::i;:::-;5969:28;:26;:28::i;:::-;5871:403;;;6032:1;6018:16;;:2;:16;;;6014:260;;;6070:28;6093:4;6070:22;:28::i;:::-;6112;:26;:28::i;:::-;6014:260;;;6195:28;6218:4;6195:22;:28::i;:::-;6237:26;6260:2;6237:22;:26::i;:::-;6014:260;5871:403;5678:602;;;:::o;7311:254:7:-;7448:43;7474:4;7480:2;7484:6;7448:25;:43::i;:::-;7502:56;7519:15;7529:4;7519:9;:15::i;:::-;7536:13;7546:2;7536:9;:13::i;:::-;7551:6;7502:16;:56::i;:::-;7311:254;;;:::o;10879:121:4:-;;;;:::o;11588:120::-;;;;:::o;9480:101:7:-;9543:7;9573:1;9569;:5;;;;:::i;:::-;9562:12;;9480:101;;;;:::o;773:112:2:-;838:7;864;:14;;;857:21;;773:112;;;:::o;586:96:1:-;639:7;665:10;658:17;;586:96;:::o;9925:370:4:-;10073:1;10056:19;;:5;:19;;;;10048:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10153:1;10134:21;;:7;:21;;;;10126:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10235:6;10205:11;:18;10217:5;10205:18;;;;;;;;;;;;;;;:27;10224:7;10205:27;;;;;;;;;;;;;;;:36;;;;10272:7;10256:32;;10265:5;10256:32;;;10281:6;10256:32;;;;;;:::i;:::-;;;;;;;;9925:370;;;:::o;7228:713::-;7381:1;7363:20;;:6;:20;;;;7355:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;7464:1;7443:23;;:9;:23;;;;7435:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;7517:47;7538:6;7546:9;7557:6;7517:20;:47::i;:::-;7575:21;7599:9;:17;7609:6;7599:17;;;;;;;;;;;;;;;;7575:41;;7651:6;7634:13;:23;;7626:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7770:6;7754:13;:22;7734:9;:17;7744:6;7734:17;;;;;;;;;;;;;;;:42;;;;7820:6;7796:9;:20;7806:9;7796:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;7859:9;7842:35;;7851:6;7842:35;;;7870:6;7842:35;;;;;;:::i;:::-;;;;;;;;7888:46;7908:6;7916:9;7927:6;7888:19;:46::i;:::-;7345:596;7228:713;;;:::o;2988:275:14:-;3041:7;3081:16;3064:13;:33;3060:197;;;3120:24;3113:31;;;;3060:197;3182:64;3204:10;3216:12;3230:15;3182:21;:64::i;:::-;3175:71;;2988:275;;:::o;4036:1444:7:-;4135:7;5128:12;5143:5;:12;;;;5128:27;;5165:11;5190:229;5203:4;5197:3;:10;5190:229;;;5223:11;5237:23;5250:3;5255:4;5237:12;:23::i;:::-;5223:37;;5301:11;5278:5;5284:3;5278:10;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;:34;;;5274:135;;;5339:3;5332:10;;5274:135;;;5393:1;5387:3;:7;;;;:::i;:::-;5381:13;;5274:135;5209:210;5190:229;;;5444:1;5436:4;:9;:37;;5452:5;5465:1;5458:4;:8;;;;:::i;:::-;5452:15;;;;;;;;:::i;:::-;;;;;;;;;:21;;;;;;;;;;;;5436:37;;;5448:1;5436:37;5429:44;;;;;;4036:1444;;;;:::o;2044:117:12:-;1611:8;:6;:8::i;:::-;1603:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;2112:5:::1;2102:7;;:15;;;;;;;;;;;;;;;;;;2132:22;2141:12;:10;:12::i;:::-;2132:22;;;;;;:::i;:::-;;;;;;;;2044:117::o:0;1219:140:17:-;1329:23;1341:2;1345:6;1329:11;:23::i;:::-;1219:140;;:::o;1365:150::-;1480:28;1492:7;1501:6;1480:11;:28::i;:::-;1365:150;;:::o;6286:1594:6:-;6375:4;6381:7;6421:1;6408:10;:14;6400:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;6481:23;:21;:23::i;:::-;6467:10;:37;;6459:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;7661:13;7677:40;7706:10;7677:9;:13;;:28;;:40;;;;:::i;:::-;7661:56;;7741:9;:13;;:20;;;;7732:5;:29;7728:146;;;7785:5;7792:1;7777:17;;;;;;;7728:146;7833:4;7839:9;:16;;7856:5;7839:23;;;;;;;;:::i;:::-;;;;;;;;;;7825:38;;;;;6286:1594;;;;;;:::o;7722:380:7:-;7806:23;7832:20;7842:9;7832;:20::i;:::-;7806:46;;7862:24;7889:20;7899:9;7889;:20::i;:::-;7862:47;;7943:9;7919:10;:21;7930:9;7919:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;8012:9;7968:54;;7995:15;7968:54;;7984:9;7968:54;;;;;;;;;;;;8033:62;8050:15;8067:9;8078:16;8033;:62::i;:::-;7796:306;;7722:380;;:::o;2032:169:11:-;2087:16;2106:6;;;;;;;;;;;2087:25;;2131:8;2122:6;;:17;;;;;;;;;;;;;;;;;;2185:8;2154:40;;2175:8;2154:40;;;;;;;;;;;;2077:124;2032:169;:::o;1797:115:12:-;1346:8;:6;:8::i;:::-;1345:9;1337:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1866:4:::1;1856:7;;:14;;;;;;;;;;;;;;;;;;1885:20;1892:12;:10;:12::i;:::-;1885:20;;;;;;:::i;:::-;;;;;;;;1797:115::o:0;4364:217:6:-;4411:7;4430:30;:18;:28;:30::i;:::-;4471:17;4491:23;:21;:23::i;:::-;4471:43;;4529:19;4538:9;4529:19;;;;;;:::i;:::-;;;;;;;;4565:9;4558:16;;;4364:217;:::o;4151:165:14:-;4228:7;4254:55;4276:20;:18;:20::i;:::-;4298:10;4254:21;:55::i;:::-;4247:62;;4151:165;;;:::o;3265:1486:3:-;3388:7;4316:66;4310:1;4302:10;;:80;;4281:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;4465:2;4460:1;:7;;;:18;;;;4476:2;4471:1;:7;;;4460:18;4452:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;4612:14;4629:24;4639:4;4645:1;4648;4651;4629:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4612:41;;4689:1;4671:20;;:6;:20;;;;4663:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;4738:6;4731:13;;;3265:1486;;;;;;:::o;2594:203:15:-;2654:15;2681:30;2714:7;:14;2722:5;2714:14;;;;;;;;;;;;;;;2681:47;;2748:15;:5;:13;:15::i;:::-;2738:25;;2773:17;:5;:15;:17::i;:::-;2671:126;2594:203;;;:::o;6422:103:7:-;6475:7;6501:17;6494:24;;6422:103;:::o;8741:631::-;8911:17;8930;8959:11;8973:5;:12;;;;8959:26;;9014:1;9007:3;:8;:35;;9022:5;9034:1;9028:3;:7;;;;:::i;:::-;9022:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;9007:35;;;9018:1;9007:35;8995:47;;;;9064:20;9067:9;9078:5;9064:2;:20;;:::i;:::-;9052:32;;9105:1;9099:3;:7;:51;;;;;9138:12;9110:5;9122:1;9116:3;:7;;;;:::i;:::-;9110:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;;;;;;;;;:40;;;9099:51;9095:271;;;9189:29;9208:9;9189:18;:29::i;:::-;9166:5;9178:1;9172:3;:7;;;;:::i;:::-;9166:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;:52;;;;;;;;;;;;;;;;;;9095:271;;;9249:5;9260:94;;;;;;;;9283:31;9301:12;9283:17;:31::i;:::-;9260:94;;;;;;9323:29;9342:9;9323:18;:29::i;:::-;9260:94;;;;;9249:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9095:271;8949:423;8741:631;;;;;;:::o;804:215:17:-;1346:8:12;:6;:8::i;:::-;1345:9;1337:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;968:44:17::1;995:4;1001:2;1005:6;968:26;:44::i;:::-;804:215:::0;;;:::o;1025:188::-;1163:43;1189:4;1195:2;1199:6;1163:25;:43::i;:::-;1025:188;;;:::o;7886:144:6:-;7953:70;7969:24;:33;7994:7;7969:33;;;;;;;;;;;;;;;8004:18;8014:7;8004:9;:18::i;:::-;7953:15;:70::i;:::-;7886:144;:::o;8036:116::-;8092:53;8108:21;8131:13;:11;:13::i;:::-;8092:15;:53::i;:::-;8036:116::o;8108:627:7:-;8235:3;8228:10;;:3;:10;;;;:24;;;;;8251:1;8242:6;:10;8228:24;8224:505;;;8287:1;8272:17;;:3;:17;;;8268:221;;8310:17;8329;8350:54;8367:12;:17;8380:3;8367:17;;;;;;;;;;;;;;;8386:9;8397:6;8350:16;:54::i;:::-;8309:95;;;;8448:3;8427:47;;;8453:9;8464;8427:47;;;;;;;:::i;:::-;;;;;;;;8291:198;;8268:221;8522:1;8507:17;;:3;:17;;;8503:216;;8545:17;8564;8585:49;8602:12;:17;8615:3;8602:17;;;;;;;;;;;;;;;8621:4;8627:6;8585:16;:49::i;:::-;8544:90;;;;8678:3;8657:47;;;8683:9;8694;8657:47;;;;;;;:::i;:::-;;;;;;;;8526:193;;8503:216;8224:505;8108:627;;;:::o;3269:257:14:-;3409:7;3456:8;3466;3476:11;3489:13;3512:4;3445:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3435:84;;;;;;3428:91;;3269:257;;;;;:::o;608:195:10:-;670:7;794:1;788;784;:5;;;;:::i;:::-;778:1;774;:5;;;;:::i;:::-;773:17;;;;:::i;:::-;772:23;;;;:::i;:::-;766:1;762;:5;;;;:::i;:::-;756:1;752;:5;;;;:::i;:::-;751:17;;;;:::i;:::-;:45;;;;:::i;:::-;744:52;;608:195;;;;:::o;6988:190:7:-;7072:28;7084:7;7093:6;7072:11;:28::i;:::-;7111:60;7128:23;7153:9;7164:6;7111:16;:60::i;:::-;;;6988:190;;:::o;4642:125:6:-;4706:7;4732:28;:18;:26;:28::i;:::-;4725:35;;4642:125;:::o;575:892:0:-;664:7;703:1;687:5;:12;;;;:17;683:56;;;727:1;720:8;;;;683:56;749:11;774:12;789:5;:12;;;;774:27;;812:414;825:4;819:3;:10;812:414;;;845:11;859:23;872:3;877:4;859:12;:23::i;:::-;845:37;;1112:7;1099:5;1105:3;1099:10;;;;;;;;:::i;:::-;;;;;;;;;;:20;1095:121;;;1146:3;1139:10;;1095:121;;;1200:1;1194:3;:7;;;;:::i;:::-;1188:13;;1095:121;831:395;812:414;;;1349:1;1343:3;:7;:36;;;;;1372:7;1354:5;1366:1;1360:3;:7;;;;:::i;:::-;1354:14;;;;;;;;:::i;:::-;;;;;;;;;;:25;1343:36;1339:122;;;1408:1;1402:3;:7;;;;:::i;:::-;1395:14;;;;;;1339:122;1447:3;1440:10;;;;575:892;;;;;:::o;891:123:2:-;996:1;978:7;:14;;;:19;;;;;;;;;;;891:123;:::o;5645:194:3:-;5738:7;5803:15;5820:10;5774:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5764:68;;;;;;5757:75;;5645:194;;;;:::o;8158:304:6:-;8252:17;8272:23;:21;:23::i;:::-;8252:43;;8342:9;8309:30;8325:9;:13;;8309:15;:30::i;:::-;:42;8305:151;;;8367:9;:13;;8386:9;8367:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8410:9;:16;;8432:12;8410:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8305:151;8242:220;8158:304;;:::o;8926:576:4:-;9028:1;9009:21;;:7;:21;;;;9001:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;9079:49;9100:7;9117:1;9121:6;9079:20;:49::i;:::-;9139:22;9164:9;:18;9174:7;9164:18;;;;;;;;;;;;;;;;9139:43;;9218:6;9200:14;:24;;9192:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;9335:6;9318:14;:23;9297:9;:18;9307:7;9297:18;;;;;;;;;;;;;;;:44;;;;9377:6;9361:12;;:22;;;;;;;:::i;:::-;;;;;;;;9425:1;9399:37;;9408:7;9399:37;;;9429:6;9399:37;;;;;;:::i;:::-;;;;;;;;9447:48;9467:7;9484:1;9488:6;9447:19;:48::i;:::-;8991:511;8926:576;;:::o;8468:206:6:-;8538:7;8575:1;8561:3;:10;;;;:15;8557:111;;;8599:1;8592:8;;;;8557:111;8638:3;8655:1;8642:3;:10;;;;:14;;;;:::i;:::-;8638:19;;;;;;;;:::i;:::-;;;;;;;;;;8631:26;;8468:206;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:139:18:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:139::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;204:87;;;;:::o;297:139::-;343:5;381:6;368:20;359:29;;397:33;424:5;397:33;:::i;:::-;349:87;;;;:::o;442:137::-;487:5;525:6;512:20;503:29;;541:32;567:5;541:32;:::i;:::-;493:86;;;;:::o;585:135::-;629:5;667:6;654:20;645:29;;683:31;708:5;683:31;:::i;:::-;635:85;;;;:::o;726:329::-;785:6;834:2;822:9;813:7;809:23;805:32;802:2;;;840:79;;:::i;:::-;802:2;960:1;985:53;1030:7;1021:6;1010:9;1006:22;985:53;:::i;:::-;975:63;;931:117;792:263;;;;:::o;1061:474::-;1129:6;1137;1186:2;1174:9;1165:7;1161:23;1157:32;1154:2;;;1192:79;;:::i;:::-;1154:2;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;1144:391;;;;;:::o;1541:619::-;1618:6;1626;1634;1683:2;1671:9;1662:7;1658:23;1654:32;1651:2;;;1689:79;;:::i;:::-;1651:2;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;1641:519;;;;;:::o;2166:1199::-;2277:6;2285;2293;2301;2309;2317;2325;2374:3;2362:9;2353:7;2349:23;2345:33;2342:2;;;2381:79;;:::i;:::-;2342:2;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;2332:1033;;;;;;;;;;:::o;3371:474::-;3439:6;3447;3496:2;3484:9;3475:7;3471:23;3467:32;3464:2;;;3502:79;;:::i;:::-;3464:2;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;3454:391;;;;;:::o;3851:1053::-;3953:6;3961;3969;3977;3985;3993;4042:3;4030:9;4021:7;4017:23;4013:33;4010:2;;;4049:79;;:::i;:::-;4010:2;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;4000:904;;;;;;;;:::o;4910:472::-;4977:6;4985;5034:2;5022:9;5013:7;5009:23;5005:32;5002:2;;;5040:79;;:::i;:::-;5002:2;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;4992:390;;;;;:::o;5388:329::-;5447:6;5496:2;5484:9;5475:7;5471:23;5467:32;5464:2;;;5502:79;;:::i;:::-;5464:2;5622:1;5647:53;5692:7;5683:6;5672:9;5668:22;5647:53;:::i;:::-;5637:63;;5593:117;5454:263;;;;:::o;5723:118::-;5810:24;5828:5;5810:24;:::i;:::-;5805:3;5798:37;5788:53;;:::o;5847:109::-;5928:21;5943:5;5928:21;:::i;:::-;5923:3;5916:34;5906:50;;:::o;5962:118::-;6049:24;6067:5;6049:24;:::i;:::-;6044:3;6037:37;6027:53;;:::o;6086:157::-;6191:45;6211:24;6229:5;6211:24;:::i;:::-;6191:45;:::i;:::-;6186:3;6179:58;6169:74;;:::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;;;;;:::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;;6765:220;;;:::o;6991:366::-;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;;7137:220;;;:::o;7363:366::-;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;;7509:220;;;:::o;7735:366::-;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;;7881:220;;;:::o;8107:366::-;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;;8253:220;;;:::o;8479:366::-;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;;8625:220;;;:::o;8851:366::-;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;;8997:220;;;:::o;9223:366::-;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;;9369:220;;;:::o;9595:366::-;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;;9741:220;;;:::o;9967:366::-;10109:3;10130:67;10194:2;10189:3;10130:67;:::i;:::-;10123:74;;10206:93;10295:3;10206:93;:::i;:::-;10324:2;10319:3;10315:12;10308:19;;10113:220;;;:::o;10339:400::-;10499:3;10520:84;10602:1;10597:3;10520:84;:::i;:::-;10513:91;;10613:93;10702:3;10613:93;:::i;:::-;10731:1;10726:3;10722:11;10715:18;;10503:236;;;:::o;10745:366::-;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;;10891:220;;;:::o;11117:366::-;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;;11263:220;;;:::o;11489:366::-;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;;11635:220;;;:::o;11861:366::-;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;;12007:220;;;:::o;12233:366::-;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;;12379:220;;;:::o;12605:366::-;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;;12751:220;;;:::o;12977:366::-;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;;13123:220;;;:::o;13349:366::-;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;;13495:220;;;:::o;13721:366::-;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;;13867:220;;;:::o;14093:366::-;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;;14239:220;;;:::o;14465:366::-;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;;14611:220;;;:::o;14837:366::-;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;;14983:220;;;:::o;15209:366::-;15351:3;15372:67;15436:2;15431:3;15372:67;:::i;:::-;15365:74;;15448:93;15537:3;15448:93;:::i;:::-;15566:2;15561:3;15557:12;15550:19;;15355:220;;;:::o;15581:366::-;15723:3;15744:67;15808:2;15803:3;15744:67;:::i;:::-;15737:74;;15820:93;15909:3;15820:93;:::i;:::-;15938:2;15933:3;15929:12;15922:19;;15727:220;;;:::o;15953:366::-;16095:3;16116:67;16180:2;16175:3;16116:67;:::i;:::-;16109:74;;16192:93;16281:3;16192:93;:::i;:::-;16310:2;16305:3;16301:12;16294:19;;16099:220;;;:::o;16325:366::-;16467:3;16488:67;16552:2;16547:3;16488:67;:::i;:::-;16481:74;;16564:93;16653:3;16564:93;:::i;:::-;16682:2;16677:3;16673:12;16666:19;;16471:220;;;:::o;16697:366::-;16839:3;16860:67;16924:2;16919:3;16860:67;:::i;:::-;16853:74;;16936:93;17025:3;16936:93;:::i;:::-;17054:2;17049:3;17045:12;17038:19;;16843:220;;;:::o;17069:366::-;17211:3;17232:67;17296:2;17291:3;17232:67;:::i;:::-;17225:74;;17308:93;17397:3;17308:93;:::i;:::-;17426:2;17421:3;17417:12;17410:19;;17215:220;;;:::o;17509:517::-;17662:4;17657:3;17653:14;17754:4;17747:5;17743:16;17737:23;17773:61;17828:4;17823:3;17819:14;17805:12;17773:61;:::i;:::-;17677:167;17927:4;17920:5;17916:16;17910:23;17946:63;18003:4;17998:3;17994:14;17980:12;17946:63;:::i;:::-;17854:165;17631:395;;;:::o;18032:108::-;18109:24;18127:5;18109:24;:::i;:::-;18104:3;18097:37;18087:53;;:::o;18146:118::-;18233:24;18251:5;18233:24;:::i;:::-;18228:3;18221:37;18211:53;;:::o;18270:105::-;18345:23;18362:5;18345:23;:::i;:::-;18340:3;18333:36;18323:52;;:::o;18381:115::-;18466:23;18483:5;18466:23;:::i;:::-;18461:3;18454:36;18444:52;;:::o;18502:112::-;18585:22;18601:5;18585:22;:::i;:::-;18580:3;18573:35;18563:51;;:::o;18620:663::-;18861:3;18883:148;19027:3;18883:148;:::i;:::-;18876:155;;19041:75;19112:3;19103:6;19041:75;:::i;:::-;19141:2;19136:3;19132:12;19125:19;;19154:75;19225:3;19216:6;19154:75;:::i;:::-;19254:2;19249:3;19245:12;19238:19;;19274:3;19267:10;;18865:418;;;;;:::o;19289:222::-;19382:4;19420:2;19409:9;19405:18;19397:26;;19433:71;19501:1;19490:9;19486:17;19477:6;19433:71;:::i;:::-;19387:124;;;;:::o;19517:210::-;19604:4;19642:2;19631:9;19627:18;19619:26;;19655:65;19717:1;19706:9;19702:17;19693:6;19655:65;:::i;:::-;19609:118;;;;:::o;19733:222::-;19826:4;19864:2;19853:9;19849:18;19841:26;;19877:71;19945:1;19934:9;19930:17;19921:6;19877:71;:::i;:::-;19831:124;;;;:::o;19961:775::-;20194:4;20232:3;20221:9;20217:19;20209:27;;20246:71;20314:1;20303:9;20299:17;20290:6;20246:71;:::i;:::-;20327:72;20395:2;20384:9;20380:18;20371:6;20327:72;:::i;:::-;20409;20477:2;20466:9;20462:18;20453:6;20409:72;:::i;:::-;20491;20559:2;20548:9;20544:18;20535:6;20491:72;:::i;:::-;20573:73;20641:3;20630:9;20626:19;20617:6;20573:73;:::i;:::-;20656;20724:3;20713:9;20709:19;20700:6;20656:73;:::i;:::-;20199:537;;;;;;;;;:::o;20742:553::-;20919:4;20957:3;20946:9;20942:19;20934:27;;20971:71;21039:1;21028:9;21024:17;21015:6;20971:71;:::i;:::-;21052:72;21120:2;21109:9;21105:18;21096:6;21052:72;:::i;:::-;21134;21202:2;21191:9;21187:18;21178:6;21134:72;:::i;:::-;21216;21284:2;21273:9;21269:18;21260:6;21216:72;:::i;:::-;20924:371;;;;;;;:::o;21301:664::-;21506:4;21544:3;21533:9;21529:19;21521:27;;21558:71;21626:1;21615:9;21611:17;21602:6;21558:71;:::i;:::-;21639:72;21707:2;21696:9;21692:18;21683:6;21639:72;:::i;:::-;21721;21789:2;21778:9;21774:18;21765:6;21721:72;:::i;:::-;21803;21871:2;21860:9;21856:18;21847:6;21803:72;:::i;:::-;21885:73;21953:3;21942:9;21938:19;21929:6;21885:73;:::i;:::-;21511:454;;;;;;;;:::o;21971:545::-;22144:4;22182:3;22171:9;22167:19;22159:27;;22196:71;22264:1;22253:9;22249:17;22240:6;22196:71;:::i;:::-;22277:68;22341:2;22330:9;22326:18;22317:6;22277:68;:::i;:::-;22355:72;22423:2;22412:9;22408:18;22399:6;22355:72;:::i;:::-;22437;22505:2;22494:9;22490:18;22481:6;22437:72;:::i;:::-;22149:367;;;;;;;:::o;22522:313::-;22635:4;22673:2;22662:9;22658:18;22650:26;;22722:9;22716:4;22712:20;22708:1;22697:9;22693:17;22686:47;22750:78;22823:4;22814:6;22750:78;:::i;:::-;22742:86;;22640:195;;;;:::o;22841:419::-;23007:4;23045:2;23034:9;23030:18;23022:26;;23094:9;23088:4;23084:20;23080:1;23069:9;23065:17;23058:47;23122:131;23248:4;23122:131;:::i;:::-;23114:139;;23012:248;;;:::o;23266:419::-;23432:4;23470:2;23459:9;23455:18;23447:26;;23519:9;23513:4;23509:20;23505:1;23494:9;23490:17;23483:47;23547:131;23673:4;23547:131;:::i;:::-;23539:139;;23437:248;;;:::o;23691:419::-;23857:4;23895:2;23884:9;23880:18;23872:26;;23944:9;23938:4;23934:20;23930:1;23919:9;23915:17;23908:47;23972:131;24098:4;23972:131;:::i;:::-;23964:139;;23862:248;;;:::o;24116:419::-;24282:4;24320:2;24309:9;24305:18;24297:26;;24369:9;24363:4;24359:20;24355:1;24344:9;24340:17;24333:47;24397:131;24523:4;24397:131;:::i;:::-;24389:139;;24287:248;;;:::o;24541:419::-;24707:4;24745:2;24734:9;24730:18;24722:26;;24794:9;24788:4;24784:20;24780:1;24769:9;24765:17;24758:47;24822:131;24948:4;24822:131;:::i;:::-;24814:139;;24712:248;;;:::o;24966:419::-;25132:4;25170:2;25159:9;25155:18;25147:26;;25219:9;25213:4;25209:20;25205:1;25194:9;25190:17;25183:47;25247:131;25373:4;25247:131;:::i;:::-;25239:139;;25137:248;;;:::o;25391:419::-;25557:4;25595:2;25584:9;25580:18;25572:26;;25644:9;25638:4;25634:20;25630:1;25619:9;25615:17;25608:47;25672:131;25798:4;25672:131;:::i;:::-;25664:139;;25562:248;;;:::o;25816:419::-;25982:4;26020:2;26009:9;26005:18;25997:26;;26069:9;26063:4;26059:20;26055:1;26044:9;26040:17;26033:47;26097:131;26223:4;26097:131;:::i;:::-;26089:139;;25987:248;;;:::o;26241:419::-;26407:4;26445:2;26434:9;26430:18;26422:26;;26494:9;26488:4;26484:20;26480:1;26469:9;26465:17;26458:47;26522:131;26648:4;26522:131;:::i;:::-;26514:139;;26412:248;;;:::o;26666:419::-;26832:4;26870:2;26859:9;26855:18;26847:26;;26919:9;26913:4;26909:20;26905:1;26894:9;26890:17;26883:47;26947:131;27073:4;26947:131;:::i;:::-;26939:139;;26837:248;;;:::o;27091:419::-;27257:4;27295:2;27284:9;27280:18;27272:26;;27344:9;27338:4;27334:20;27330:1;27319:9;27315:17;27308:47;27372:131;27498:4;27372:131;:::i;:::-;27364:139;;27262:248;;;:::o;27516:419::-;27682:4;27720:2;27709:9;27705:18;27697:26;;27769:9;27763:4;27759:20;27755:1;27744:9;27740:17;27733:47;27797:131;27923:4;27797:131;:::i;:::-;27789:139;;27687:248;;;:::o;27941:419::-;28107:4;28145:2;28134:9;28130:18;28122:26;;28194:9;28188:4;28184:20;28180:1;28169:9;28165:17;28158:47;28222:131;28348:4;28222:131;:::i;:::-;28214:139;;28112:248;;;:::o;28366:419::-;28532:4;28570:2;28559:9;28555:18;28547:26;;28619:9;28613:4;28609:20;28605:1;28594:9;28590:17;28583:47;28647:131;28773:4;28647:131;:::i;:::-;28639:139;;28537:248;;;:::o;28791:419::-;28957:4;28995:2;28984:9;28980:18;28972:26;;29044:9;29038:4;29034:20;29030:1;29019:9;29015:17;29008:47;29072:131;29198:4;29072:131;:::i;:::-;29064:139;;28962:248;;;:::o;29216:419::-;29382:4;29420:2;29409:9;29405:18;29397:26;;29469:9;29463:4;29459:20;29455:1;29444:9;29440:17;29433:47;29497:131;29623:4;29497:131;:::i;:::-;29489:139;;29387:248;;;:::o;29641:419::-;29807:4;29845:2;29834:9;29830:18;29822:26;;29894:9;29888:4;29884:20;29880:1;29869:9;29865:17;29858:47;29922:131;30048:4;29922:131;:::i;:::-;29914:139;;29812:248;;;:::o;30066:419::-;30232:4;30270:2;30259:9;30255:18;30247:26;;30319:9;30313:4;30309:20;30305:1;30294:9;30290:17;30283:47;30347:131;30473:4;30347:131;:::i;:::-;30339:139;;30237:248;;;:::o;30491:419::-;30657:4;30695:2;30684:9;30680:18;30672:26;;30744:9;30738:4;30734:20;30730:1;30719:9;30715:17;30708:47;30772:131;30898:4;30772:131;:::i;:::-;30764:139;;30662:248;;;:::o;30916:419::-;31082:4;31120:2;31109:9;31105:18;31097:26;;31169:9;31163:4;31159:20;31155:1;31144:9;31140:17;31133:47;31197:131;31323:4;31197:131;:::i;:::-;31189:139;;31087:248;;;:::o;31341:419::-;31507:4;31545:2;31534:9;31530:18;31522:26;;31594:9;31588:4;31584:20;31580:1;31569:9;31565:17;31558:47;31622:131;31748:4;31622:131;:::i;:::-;31614:139;;31512:248;;;:::o;31766:419::-;31932:4;31970:2;31959:9;31955:18;31947:26;;32019:9;32013:4;32009:20;32005:1;31994:9;31990:17;31983:47;32047:131;32173:4;32047:131;:::i;:::-;32039:139;;31937:248;;;:::o;32191:419::-;32357:4;32395:2;32384:9;32380:18;32372:26;;32444:9;32438:4;32434:20;32430:1;32419:9;32415:17;32408:47;32472:131;32598:4;32472:131;:::i;:::-;32464:139;;32362:248;;;:::o;32616:419::-;32782:4;32820:2;32809:9;32805:18;32797:26;;32869:9;32863:4;32859:20;32855:1;32844:9;32840:17;32833:47;32897:131;33023:4;32897:131;:::i;:::-;32889:139;;32787:248;;;:::o;33041:419::-;33207:4;33245:2;33234:9;33230:18;33222:26;;33294:9;33288:4;33284:20;33280:1;33269:9;33265:17;33258:47;33322:131;33448:4;33322:131;:::i;:::-;33314:139;;33212:248;;;:::o;33466:419::-;33632:4;33670:2;33659:9;33655:18;33647:26;;33719:9;33713:4;33709:20;33705:1;33694:9;33690:17;33683:47;33747:131;33873:4;33747:131;:::i;:::-;33739:139;;33637:248;;;:::o;33891:419::-;34057:4;34095:2;34084:9;34080:18;34072:26;;34144:9;34138:4;34134:20;34130:1;34119:9;34115:17;34108:47;34172:131;34298:4;34172:131;:::i;:::-;34164:139;;34062:248;;;:::o;34316:419::-;34482:4;34520:2;34509:9;34505:18;34497:26;;34569:9;34563:4;34559:20;34555:1;34544:9;34540:17;34533:47;34597:131;34723:4;34597:131;:::i;:::-;34589:139;;34487:248;;;:::o;34741:334::-;34890:4;34928:2;34917:9;34913:18;34905:26;;34941:127;35065:1;35054:9;35050:17;35041:6;34941:127;:::i;:::-;34895:180;;;;:::o;35081:222::-;35174:4;35212:2;35201:9;35197:18;35189:26;;35225:71;35293:1;35282:9;35278:17;35269:6;35225:71;:::i;:::-;35179:124;;;;:::o;35309:332::-;35430:4;35468:2;35457:9;35453:18;35445:26;;35481:71;35549:1;35538:9;35534:17;35525:6;35481:71;:::i;:::-;35562:72;35630:2;35619:9;35615:18;35606:6;35562:72;:::i;:::-;35435:206;;;;;:::o;35647:218::-;35738:4;35776:2;35765:9;35761:18;35753:26;;35789:69;35855:1;35844:9;35840:17;35831:6;35789:69;:::i;:::-;35743:122;;;;:::o;35871:214::-;35960:4;35998:2;35987:9;35983:18;35975:26;;36011:67;36075:1;36064:9;36060:17;36051:6;36011:67;:::i;:::-;35965:120;;;;:::o;36172:99::-;36224:6;36258:5;36252:12;36242:22;;36231:40;;;:::o;36277:169::-;36361:11;36395:6;36390:3;36383:19;36435:4;36430:3;36426:14;36411:29;;36373:73;;;;:::o;36452:148::-;36554:11;36591:3;36576:18;;36566:34;;;;:::o;36606:305::-;36646:3;36665:20;36683:1;36665:20;:::i;:::-;36660:25;;36699:20;36717:1;36699:20;:::i;:::-;36694:25;;36853:1;36785:66;36781:74;36778:1;36775:81;36772:2;;;36859:18;;:::i;:::-;36772:2;36903:1;36900;36896:9;36889:16;;36650:261;;;;:::o;36917:185::-;36957:1;36974:20;36992:1;36974:20;:::i;:::-;36969:25;;37008:20;37026:1;37008:20;:::i;:::-;37003:25;;37047:1;37037:2;;37052:18;;:::i;:::-;37037:2;37094:1;37091;37087:9;37082:14;;36959:143;;;;:::o;37108:191::-;37148:4;37168:20;37186:1;37168:20;:::i;:::-;37163:25;;37202:20;37220:1;37202:20;:::i;:::-;37197:25;;37241:1;37238;37235:8;37232:2;;;37246:18;;:::i;:::-;37232:2;37291:1;37288;37284:9;37276:17;;37153:146;;;;:::o;37305:96::-;37342:7;37371:24;37389:5;37371:24;:::i;:::-;37360:35;;37350:51;;;:::o;37407:90::-;37441:7;37484:5;37477:13;37470:21;37459:32;;37449:48;;;:::o;37503:77::-;37540:7;37569:5;37558:16;;37548:32;;;:::o;37586:126::-;37623:7;37663:42;37656:5;37652:54;37641:65;;37631:81;;;:::o;37718:142::-;37755:7;37795:58;37788:5;37784:70;37773:81;;37763:97;;;:::o;37866:77::-;37903:7;37932:5;37921:16;;37911:32;;;:::o;37949:93::-;37985:7;38025:10;38018:5;38014:22;38003:33;;37993:49;;;:::o;38048:86::-;38083:7;38123:4;38116:5;38112:16;38101:27;;38091:43;;;:::o;38140:307::-;38208:1;38218:113;38232:6;38229:1;38226:13;38218:113;;;38317:1;38312:3;38308:11;38302:18;38298:1;38293:3;38289:11;38282:39;38254:2;38251:1;38247:10;38242:15;;38218:113;;;38349:6;38346:1;38343:13;38340:2;;;38429:1;38420:6;38415:3;38411:16;38404:27;38340:2;38189:258;;;;:::o;38453:320::-;38497:6;38534:1;38528:4;38524:12;38514:22;;38581:1;38575:4;38571:12;38602:18;38592:2;;38658:4;38650:6;38646:17;38636:27;;38592:2;38720;38712:6;38709:14;38689:18;38686:38;38683:2;;;38739:18;;:::i;:::-;38683:2;38504:269;;;;:::o;38779:79::-;38818:7;38847:5;38836:16;;38826:32;;;:::o;38864:176::-;38896:1;38913:20;38931:1;38913:20;:::i;:::-;38908:25;;38947:20;38965:1;38947:20;:::i;:::-;38942:25;;38986:1;38976:2;;38991:18;;:::i;:::-;38976:2;39032:1;39029;39025:9;39020:14;;38898:142;;;;:::o;39046:180::-;39094:77;39091:1;39084:88;39191:4;39188:1;39181:15;39215:4;39212:1;39205:15;39232:180;39280:77;39277:1;39270:88;39377:4;39374:1;39367:15;39401:4;39398:1;39391:15;39418:180;39466:77;39463:1;39456:88;39563:4;39560:1;39553:15;39587:4;39584:1;39577:15;39604:180;39652:77;39649:1;39642:88;39749:4;39746:1;39739:15;39773:4;39770:1;39763:15;39913:117;40022:1;40019;40012:12;40036:102;40077:6;40128:2;40124:7;40119:2;40112:5;40108:14;40104:28;40094:38;;40084:54;;;:::o;40144:174::-;40284:26;40280:1;40272:6;40268:14;40261:50;40250:68;:::o;40324:179::-;40464:31;40460:1;40452:6;40448:14;40441:55;40430:73;:::o;40509:222::-;40649:34;40645:1;40637:6;40633:14;40626:58;40718:5;40713:2;40705:6;40701:15;40694:30;40615:116;:::o;40737:181::-;40877:33;40873:1;40865:6;40861:14;40854:57;40843:75;:::o;40924:170::-;41064:22;41060:1;41052:6;41048:14;41041:46;41030:64;:::o;41100:179::-;41240:31;41236:1;41228:6;41224:14;41217:55;41206:73;:::o;41285:221::-;41425:34;41421:1;41413:6;41409:14;41402:58;41494:4;41489:2;41481:6;41477:15;41470:29;41391:115;:::o;41512:175::-;41652:27;41648:1;41640:6;41636:14;41629:51;41618:69;:::o;41693:225::-;41833:34;41829:1;41821:6;41817:14;41810:58;41902:8;41897:2;41889:6;41885:15;41878:33;41799:119;:::o;41924:221::-;42064:34;42060:1;42052:6;42048:14;42041:58;42133:4;42128:2;42120:6;42116:15;42109:29;42030:115;:::o;42151:214::-;42291:66;42287:1;42279:6;42275:14;42268:90;42257:108;:::o;42371:179::-;42511:31;42507:1;42499:6;42495:14;42488:55;42477:73;:::o;42556:225::-;42696:34;42692:1;42684:6;42680:14;42673:58;42765:8;42760:2;42752:6;42748:15;42741:33;42662:119;:::o;42787:221::-;42927:34;42923:1;42915:6;42911:14;42904:58;42996:4;42991:2;42983:6;42979:15;42972:29;42893:115;:::o;43014:166::-;43154:18;43150:1;43142:6;43138:14;43131:42;43120:60;:::o;43186:221::-;43326:34;43322:1;43314:6;43310:14;43303:58;43395:4;43390:2;43382:6;43378:15;43371:29;43292:115;:::o;43413:180::-;43553:32;43549:1;43541:6;43537:14;43530:56;43519:74;:::o;43599:227::-;43739:34;43735:1;43727:6;43723:14;43716:58;43808:10;43803:2;43795:6;43791:15;43784:35;43705:121;:::o;43832:235::-;43972:34;43968:1;43960:6;43956:14;43949:58;44041:18;44036:2;44028:6;44024:15;44017:43;43938:129;:::o;44073:182::-;44213:34;44209:1;44201:6;44197:14;44190:58;44179:76;:::o;44261:226::-;44401:34;44397:1;44389:6;44385:14;44378:58;44470:9;44465:2;44457:6;44453:15;44446:34;44367:120;:::o;44493:223::-;44633:34;44629:1;44621:6;44617:14;44610:58;44702:6;44697:2;44689:6;44685:15;44678:31;44599:117;:::o;44722:220::-;44862:34;44858:1;44850:6;44846:14;44839:58;44931:3;44926:2;44918:6;44914:15;44907:28;44828:114;:::o;44948:224::-;45088:34;45084:1;45076:6;45072:14;45065:58;45157:7;45152:2;45144:6;45140:15;45133:32;45054:118;:::o;45178:225::-;45318:34;45314:1;45306:6;45302:14;45295:58;45387:8;45382:2;45374:6;45370:15;45363:33;45284:119;:::o;45409:223::-;45549:34;45545:1;45537:6;45533:14;45526:58;45618:6;45613:2;45605:6;45601:15;45594:31;45515:117;:::o;45638:172::-;45778:24;45774:1;45766:6;45762:14;45755:48;45744:66;:::o;45816:224::-;45956:34;45952:1;45944:6;45940:14;45933:58;46025:7;46020:2;46012:6;46008:15;46001:32;45922:118;:::o;46046:181::-;46186:33;46182:1;46174:6;46170:14;46163:57;46152:75;:::o;46233:122::-;46306:24;46324:5;46306:24;:::i;:::-;46299:5;46296:35;46286:2;;46345:1;46342;46335:12;46286:2;46276:79;:::o;46361:122::-;46434:24;46452:5;46434:24;:::i;:::-;46427:5;46424:35;46414:2;;46473:1;46470;46463:12;46414:2;46404:79;:::o;46489:122::-;46562:24;46580:5;46562:24;:::i;:::-;46555:5;46552:35;46542:2;;46601:1;46598;46591:12;46542:2;46532:79;:::o;46617:120::-;46689:23;46706:5;46689:23;:::i;:::-;46682:5;46679:34;46669:2;;46727:1;46724;46717:12;46669:2;46659:78;:::o;46743:118::-;46814:22;46830:5;46814:22;:::i;:::-;46807:5;46804:33;46794:2;;46851:1;46848;46841:12;46794:2;46784:77;:::o
Swarm Source
ipfs://99bab78d2234969dcf2f5e2d949709f13e913130d0845a5b2da525ce79c9e2ee
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.