Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
13011203 | 1051 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Contract Name:
TimelockRewardDistributionTokenImpl
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-08-30 */ // Sources flattened with hardhat v2.4.3 https://hardhat.org // File contracts/solidity/token/IERC20Upgradeable.sol // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20Upgradeable { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `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 ); } // File contracts/solidity/token/IERC20Metadata.sol pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20Upgradeable { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File contracts/solidity/proxy/Initializable.sol // solhint-disable-next-line compiler-version pragma solidity ^0.8.0; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { require( _initializing || !_initialized, "Initializable: contract is already initialized" ); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } } // File contracts/solidity/util/ContextUpgradeable.sol pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer {} function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } uint256[50] private __gap; } // File contracts/solidity/token/ERC20Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin 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 ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, 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. */ function __ERC20_init(string memory name_, string memory symbol_) internal initializer { __Context_init_unchained(); __ERC20_init_unchained(name_, symbol_); } function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer { _name = name_; _symbol = symbol_; } function _setMetadata(string memory name_, string memory symbol_) internal { _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" ); _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" ); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is 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" ); _balances[sender] = senderBalance - amount; _balances[recipient] += amount; emit Transfer(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); } /** * @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"); _balances[account] = accountBalance - amount; _totalSupply -= amount; emit Transfer(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 to 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 {} uint256[45] private __gap; } // File contracts/solidity/interface/IRewardDistributionToken.sol pragma solidity ^0.8.0; interface IRewardDistributionToken is IERC20Upgradeable { function distributeRewards(uint256 amount) external; function __RewardDistributionToken_init( IERC20Upgradeable _target, string memory _name, string memory _symbol ) external; function mint( address account, address to, uint256 amount ) external; function burnFrom(address account, uint256 amount) external; function withdrawReward(address user) external; function dividendOf(address _owner) external view returns (uint256); function withdrawnRewardOf(address _owner) external view returns (uint256); function accumulativeRewardOf(address _owner) external view returns (uint256); } // File contracts/solidity/util/OwnableUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal initializer { __Context_init_unchained(); __Ownable_init_unchained(); } function __Ownable_init_unchained() internal initializer { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), 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 { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require( newOwner != address(0), "Ownable: new owner is the zero address" ); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } uint256[49] private __gap; } // File contracts/solidity/util/Address.sol pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{value: amount}(""); require( success, "Address: unable to send value, recipient may have reverted" ); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, "Address: low-level call with value failed" ); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require( address(this).balance >= value, "Address: insufficient balance for call" ); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value: value}( data ); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall( target, data, "Address: low-level static call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File contracts/solidity/util/SafeERC20Upgradeable.sol pragma solidity ^0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20Upgradeable { using Address for address; function safeTransfer( IERC20Upgradeable token, address to, uint256 value ) internal { _callOptionalReturn( token, abi.encodeWithSelector(token.transfer.selector, to, value) ); } function safeTransferFrom( IERC20Upgradeable token, address from, address to, uint256 value ) internal { _callOptionalReturn( token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value) ); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20Upgradeable token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn( token, abi.encodeWithSelector(token.approve.selector, spender, value) ); } function safeIncreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn( token, abi.encodeWithSelector( token.approve.selector, spender, newAllowance ) ); } function safeDecreaseAllowance( IERC20Upgradeable token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require( oldAllowance >= value, "SafeERC20: decreased allowance below zero" ); uint256 newAllowance = oldAllowance - value; _callOptionalReturn( token, abi.encodeWithSelector( token.approve.selector, spender, newAllowance ) ); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall( data, "SafeERC20: low-level call failed" ); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require( abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed" ); } } } // File contracts/solidity/util/SafeMathUpgradeable.sol pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMathUpgradeable { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } /** * @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) { require(value < 2**255, "SafeCast: value doesn't fit in an int256"); return int256(value); } } // File contracts/solidity/util/SafeMathInt.sol pragma solidity ^0.8.0; /** * @title SafeMathInt * @dev Math operations with safety checks that revert on error * @dev SafeMath adapted for int256 * Based on code of https://github.com/RequestNetwork/requestNetwork/blob/master/packages/requestNetworkSmartContracts/contracts/base/math/SafeMathInt.sol */ library SafeMathInt { function mul(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when multiplying INT256_MIN with -1 // https://github.com/RequestNetwork/requestNetwork/issues/43 require(!(a == -2**255 && b == -1) && !(b == -2**255 && a == -1)); int256 c = a * b; require((b == 0) || (c / b == a)); return c; } function div(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when dividing INT256_MIN by -1 // https://github.com/RequestNetwork/requestNetwork/issues/43 require(!(a == -2**255 && b == -1) && (b > 0)); return a / b; } function sub(int256 a, int256 b) internal pure returns (int256) { require((b >= 0 && a - b <= a) || (b < 0 && a - b > a)); return a - b; } function add(int256 a, int256 b) internal pure returns (int256) { int256 c = a + b; require((b >= 0 && c >= a) || (b < 0 && c < a)); return c; } function toUint256Safe(int256 a) internal pure returns (uint256) { require(a >= 0); return uint256(a); } } // File contracts/solidity/token/TimelockRewardDistributionTokenImpl.sol pragma solidity ^0.8.0; /// @title Reward-Paying Token (renamed from Dividend) /// @author Roger Wu (https://github.com/roger-wu) /// @dev A mintable ERC20 token that allows anyone to pay and distribute a target token /// to token holders as dividends and allows token holders to withdraw their dividends. /// Reference: the source code of PoWH3D: https://etherscan.io/address/0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe#code contract TimelockRewardDistributionTokenImpl is OwnableUpgradeable, ERC20Upgradeable { using SafeMathUpgradeable for uint256; using SafeMathInt for int256; using SafeERC20Upgradeable for IERC20Upgradeable; IERC20Upgradeable public target; // With `magnitude`, we can properly distribute dividends even if the amount of received target is small. // For more discussion about choosing the value of `magnitude`, // see https://github.com/ethereum/EIPs/issues/1726#issuecomment-472352728 uint256 internal constant magnitude = 2**128; uint256 internal magnifiedRewardPerShare; // About dividendCorrection: // If the token balance of a `_user` is never changed, the dividend of `_user` can be computed with: // `dividendOf(_user) = dividendPerShare * balanceOf(_user)`. // When `balanceOf(_user)` is changed (via minting/burning/transferring tokens), // `dividendOf(_user)` should not be changed, // but the computed value of `dividendPerShare * balanceOf(_user)` is changed. // To keep the `dividendOf(_user)` unchanged, we add a correction term: // `dividendOf(_user) = dividendPerShare * balanceOf(_user) + dividendCorrectionOf(_user)`, // where `dividendCorrectionOf(_user)` is updated whenever `balanceOf(_user)` is changed: // `dividendCorrectionOf(_user) = dividendPerShare * (old balanceOf(_user)) - (new balanceOf(_user))`. // So now `dividendOf(_user)` returns the same value before and after `balanceOf(_user)` is changed. mapping(address => int256) internal magnifiedRewardCorrections; mapping(address => uint256) internal withdrawnRewards; mapping(address => uint256) internal timelock; event Timelocked(address user, uint256 amount, uint256 until); function __TimelockRewardDistributionToken_init( IERC20Upgradeable _target, string memory _name, string memory _symbol ) public initializer { __Ownable_init(); __ERC20_init(_name, _symbol); target = _target; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, 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); _approve( sender, _msgSender(), allowance(sender, _msgSender()).sub( amount, "ERC20: transfer amount exceeds allowance" ) ); return true; } function mint(address account, uint256 amount) public virtual onlyOwner { _mint(account, amount); } function timelockMint( address account, uint256 amount, uint256 timelockLength ) public virtual onlyOwner { uint256 timelockFinish = block.timestamp + timelockLength; timelock[account] = timelockFinish; emit Timelocked(account, amount, timelockFinish); _mint(account, amount); } function timelockUntil(address account) public view returns (uint256) { return timelock[account]; } /** * @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 onlyOwner { _burn(account, amount); } /// @notice Distributes target to token holders as dividends. /// @dev It reverts if the total supply of tokens is 0. /// It emits the `RewardsDistributed` event if the amount of received target is greater than 0. /// About undistributed target tokens: /// In each distribution, there is a small amount of target not distributed, /// the magnified amount of which is /// `(amount * magnitude) % totalSupply()`. /// With a well-chosen `magnitude`, the amount of undistributed target /// (de-magnified) in a distribution can be less than 1 wei. /// We can actually keep track of the undistributed target in a distribution /// and try to distribute it in the next distribution, /// but keeping track of such data on-chain costs much more than /// the saved target, so we don't do that. function distributeRewards(uint256 amount) external virtual onlyOwner { require(totalSupply() > 0, "RewardDist: 0 supply"); require(amount > 0, "RewardDist: 0 amount"); // Because we receive the tokens from the staking contract, we assume the tokens have been received. magnifiedRewardPerShare = magnifiedRewardPerShare.add( (amount).mul(magnitude) / totalSupply() ); emit RewardsDistributed(msg.sender, amount); } /// @notice Withdraws the target distributed to the sender. /// @dev It emits a `RewardWithdrawn` event if the amount of withdrawn target is greater than 0. function withdrawReward(address user) external onlyOwner { uint256 _withdrawableReward = withdrawableRewardOf(user); if (_withdrawableReward > 0) { withdrawnRewards[user] = withdrawnRewards[user].add( _withdrawableReward ); target.safeTransfer(user, _withdrawableReward); emit RewardWithdrawn(user, _withdrawableReward); } } /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function dividendOf(address _owner) public view returns (uint256) { return withdrawableRewardOf(_owner); } /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function withdrawableRewardOf(address _owner) internal view returns (uint256) { return accumulativeRewardOf(_owner).sub(withdrawnRewards[_owner]); } /// @notice View the amount of dividend in wei that an address has withdrawn. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has withdrawn. function withdrawnRewardOf(address _owner) public view returns (uint256) { return withdrawnRewards[_owner]; } /// @notice View the amount of dividend in wei that an address has earned in total. /// @dev accumulativeRewardOf(_owner) = withdrawableRewardOf(_owner) + withdrawnRewardOf(_owner) /// = (magnifiedRewardPerShare * balanceOf(_owner) + magnifiedRewardCorrections[_owner]) / magnitude /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has earned in total. function accumulativeRewardOf(address _owner) public view returns (uint256) { return magnifiedRewardPerShare .mul(balanceOf(_owner)) .toInt256() .add(magnifiedRewardCorrections[_owner]) .toUint256Safe() / magnitude; } /// @dev Internal function that transfer tokens from one address to another. /// Update magnifiedRewardCorrections to keep dividends unchanged. /// @param from The address to transfer from. /// @param to The address to transfer to. /// @param value The amount to be transferred. function _transfer( address from, address to, uint256 value ) internal override { require(block.timestamp > timelock[from], "User locked"); super._transfer(from, to, value); int256 _magCorrection = magnifiedRewardPerShare.mul(value).toInt256(); magnifiedRewardCorrections[from] = magnifiedRewardCorrections[from].add( _magCorrection ); magnifiedRewardCorrections[to] = magnifiedRewardCorrections[to].sub( _magCorrection ); } /// @dev Internal function that mints tokens to an account. /// Update magnifiedRewardCorrections to keep dividends unchanged. /// @param account The account that will receive the created tokens. /// @param value The amount that will be created. function _mint(address account, uint256 value) internal override { super._mint(account, value); magnifiedRewardCorrections[account] = magnifiedRewardCorrections[ account ].sub((magnifiedRewardPerShare.mul(value)).toInt256()); } /// @dev Internal function that burns an amount of the token of a given account. /// Update magnifiedRewardCorrections to keep dividends unchanged. /// @param account The account whose tokens will be burnt. /// @param value The amount that will be burnt. function _burn(address account, uint256 value) internal override { require(block.timestamp > timelock[account], "User locked"); super._burn(account, value); magnifiedRewardCorrections[account] = magnifiedRewardCorrections[ account ].add((magnifiedRewardPerShare.mul(value)).toInt256()); } /// @dev This event MUST emit when target is distributed to token holders. /// @param from The address which sends target to this contract. /// @param weiAmount The amount of distributed target in wei. event RewardsDistributed(address indexed from, uint256 weiAmount); /// @dev This event MUST emit when an address withdraws their dividend. /// @param to The address which withdraws target from this contract. /// @param weiAmount The amount of withdrawn target in wei. event RewardWithdrawn(address indexed to, uint256 weiAmount); }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"RewardWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"RewardsDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"until","type":"uint256"}],"name":"Timelocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"_target","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"name":"__TimelockRewardDistributionToken_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeRewardOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"amount","type":"uint256"}],"name":"distributeRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","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":"account","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":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"target","outputs":[{"internalType":"contract IERC20Upgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"timelockLength","type":"uint256"}],"name":"timelockMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"timelockUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":[{"internalType":"address","name":"user","type":"address"}],"name":"withdrawReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnRewardOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
45010:10795:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52843:344;;;;;;:::i;:::-;;:::i;:::-;;;13424:25:1;;;13412:2;13397:18;52843:344:0;;;;;;;;9293:100;;;:::i;:::-;;;;;;;:::i;11601:210::-;;;;;;:::i;:::-;;:::i;:::-;;;5206:14:1;;5199:22;5181:41;;5169:2;5154:18;11601:210:0;5136:92:1;10413:108:0;10501:12;;10413:108;;47809:452;;;;;;:::i;:::-;;:::i;48390:351::-;;;;;;:::i;:::-;;:::i;:::-;;10255:93;;;10338:2;13602:36:1;;13590:2;13575:18;10255:93:0;13557:87:1;13195:297:0;;;;;;:::i;:::-;;:::i;48269:113::-;;;;;;:::i;:::-;;:::i;50216:490::-;;;;;;:::i;:::-;;:::i;10584:177::-;;;;;;:::i;:::-;-1:-1:-1;;;;;10735:18:0;10703:7;10735:18;;;:9;:18;;;;;;;10584:177;21515:148;;;:::i;49181:149::-;;;;;;:::i;:::-;;:::i;20864:87::-;20937:6;;-1:-1:-1;;;;;20937:6:0;20864:87;;;-1:-1:-1;;;;;4299:55:1;;;4281:74;;4269:2;4254:18;20864:87:0;4236:125:1;51525:120:0;;;;;;:::i;:::-;;:::i;9512:104::-;;;:::i;46830:273::-;;;;;;:::i;:::-;;:::i;13995:446::-;;;;;;:::i;:::-;;:::i;47111:216::-;;;;;;:::i;:::-;;:::i;52279:123::-;;;;;;:::i;:::-;-1:-1:-1;;;;;52370:24:0;52343:7;52370:24;;;:16;:24;;;;;;;52279:123;50881:425;;;;;;:::i;:::-;;:::i;48749:113::-;;;;;;:::i;:::-;-1:-1:-1;;;;;48837:17:0;48810:7;48837:17;;;:8;:17;;;;;;;48749:113;45249:31;;;;;-1:-1:-1;;;;;45249:31:0;;;11253:201;;;;;;:::i;:::-;-1:-1:-1;;;;;11419:18:0;;;11387:7;11419:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11253:201;21818:281;;;;;;:::i;:::-;;:::i;52843:344::-;-1:-1:-1;;;;;53098:34:0;;52937:7;53098:34;;;:26;:34;;;;;;;;;10735:9;:18;;;;;;52982:23;;45588:6;;52982:185;;:151;;:93;;:64;;:23;:45;:64::i;:::-;:91;:93::i;:::-;:115;;:151::i;:::-;:183;:185::i;:::-;:197;;;;:::i;:::-;52962:217;52843:344;-1:-1:-1;;52843:344:0:o;9293:100::-;9347:13;9380:5;9373:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9293:100;:::o;11601:210::-;11720:4;11742:39;6452:10;11765:7;11774:6;11742:8;:39::i;:::-;-1:-1:-1;11799:4:0;11601:210;;;;:::o;47809:452::-;47949:4;47966:36;47976:6;47984:9;47995:6;47966:9;:36::i;:::-;48013:218;48036:6;6452:10;48084:136;48138:6;48084:136;;;;;;;;;;;;;;;;;:31;48094:6;6452:10;11253:201;:::i;48084:31::-;:35;:136;:35;:136::i;:::-;48013:8;:218::i;:::-;-1:-1:-1;48249:4:0;47809:452;;;;;;:::o;48390:351::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;;;;;;;;;48539:22:::1;48564:32;48582:14:::0;48564:15:::1;:32;:::i;:::-;-1:-1:-1::0;;;;;48607:17:0;::::1;;::::0;;;:8:::1;:17;::::0;;;;;;;;:34;;;48657:43;;4870:74:1;;;4960:18;;4953:34;;;5003:18;;4996:34;;;48607::0;;-1:-1:-1;48657:43:0::1;::::0;4858:2:1;4843:18;48657:43:0::1;;;;;;;48711:22;48717:7;48726:6;48711:5;:22::i;:::-;21155:1;48390:351:::0;;;:::o;13195:297::-;6452:10;13310:4;13404:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;13404:34:0;;;;;;;;;;13310:4;;13332:130;;13382:7;;13404:47;;13441:10;;13404:47;:::i;48269:113::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;48352:22:::1;48358:7;48367:6;48352:5;:22::i;:::-;48269:113:::0;;:::o;50216:490::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;50321:1:::1;50305:13;10501:12:::0;;;10413:108;50305:13:::1;:17;50297:50;;;::::0;-1:-1:-1;;;50297:50:0;;8924:2:1;50297:50:0::1;::::0;::::1;8906:21:1::0;8963:2;8943:18;;;8936:30;9002:22;8982:18;;;8975:50;9042:18;;50297:50:0::1;8896:170:1::0;50297:50:0::1;50375:1;50366:6;:10;50358:43;;;::::0;-1:-1:-1;;;50358:43:0;;12025:2:1;50358:43:0::1;::::0;::::1;12007:21:1::0;12064:2;12044:18;;;12037:30;12103:22;12083:18;;;12076:50;12143:18;;50358:43:0::1;11997:170:1::0;50358:43:0::1;50550:92;50618:13;10501:12:::0;;;10413:108;50618:13:::1;50592:23;50593:6:::0;45588::::1;50592:12;:23::i;:::-;:39;;;;:::i;:::-;50550:23;::::0;;:27:::1;:92::i;:::-;50524:23;:118:::0;50660:38:::1;::::0;13424:25:1;;;50679:10:0::1;::::0;50660:38:::1;::::0;13412:2:1;13397:18;50660:38:0::1;;;;;;;50216:490:::0;:::o;21515:148::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;21606:6:::1;::::0;21585:40:::1;::::0;21622:1:::1;::::0;-1:-1:-1;;;;;21606:6:0::1;::::0;21585:40:::1;::::0;21622:1;;21585:40:::1;21636:6;:19:::0;;-1:-1:-1;;21636:19:0::1;::::0;;21515:148::o;49181:149::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;49300:22:::1;49306:7;49315:6;49300:5;:22::i;51525:120::-:0;51582:7;51609:28;51630:6;51609:20;:28::i;9512:104::-;9568:13;9601:7;9594:14;;;;;:::i;46830:273::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5344:101;47013:16:::1;:14;:16::i;:::-;47040:28;47053:5;47060:7;47040:12;:28::i;:::-;47079:6;:16:::0;;-1:-1:-1;;47079:16:0::1;-1:-1:-1::0;;;;;47079:16:0;::::1;;::::0;;5471:68;;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;46830:273;;;;:::o;13995:446::-;6452:10;14115:4;14164:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;14164:34:0;;;;;;;;;;14231:35;;;;14209:122;;;;-1:-1:-1;;;14209:122:0;;12714:2:1;14209:122:0;;;12696:21:1;12753:2;12733:18;;;12726:30;12792:34;12772:18;;;12765:62;12863:7;12843:18;;;12836:35;12888:19;;14209:122:0;12686:227:1;14209:122:0;14342:67;6452:10;14365:7;14374:34;14393:15;14374:16;:34;:::i;47111:216::-;47233:4;47255:42;6452:10;47279:9;47290:6;47255:9;:42::i;50881:425::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;50949:27:::1;50979:26;51000:4;50979:20;:26::i;:::-;50949:56:::0;-1:-1:-1;51020:23:0;;51016:283:::1;;-1:-1:-1::0;;;;;51085:22:0;::::1;;::::0;;;:16:::1;:22;::::0;;;;;:79:::1;::::0;51130:19;51085:26:::1;:79::i;:::-;-1:-1:-1::0;;;;;51060:22:0;;::::1;;::::0;;;:16:::1;:22;::::0;;;;:104;;;;51179:6:::1;::::0;:46:::1;::::0;:6:::1;51077:4:::0;51205:19;51179::::1;:46::i;:::-;51261:4;-1:-1:-1::0;;;;;51245:42:0::1;;51267:19;51245:42;;;;13424:25:1::0;;13412:2;13397:18;;13379:76;51245:42:0::1;;;;;;;;21155:1;50881:425:::0;:::o;21818:281::-;20937:6;;-1:-1:-1;;;;;20937:6:0;6452:10;21084:23;21076:68;;;;-1:-1:-1;;;21076:68:0;;9273:2:1;21076:68:0;;;9255:21:1;;;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;9403:18;;21076:68:0;9245:182:1;21076:68:0;-1:-1:-1;;;;;21921:22:0;::::1;21899:110;;;::::0;-1:-1:-1;;;21899:110:0;;6885:2:1;21899:110:0::1;::::0;::::1;6867:21:1::0;6924:2;6904:18;;;6897:30;6963:34;6943:18;;;6936:62;7034:8;7014:18;;;7007:36;7060:19;;21899:110:0::1;6857:228:1::0;21899:110:0::1;22046:6;::::0;22025:38:::1;::::0;-1:-1:-1;;;;;22025:38:0;;::::1;::::0;22046:6:::1;::::0;22025:38:::1;::::0;22046:6:::1;::::0;22025:38:::1;22074:6;:17:::0;;-1:-1:-1;;22074:17:0::1;-1:-1:-1::0;;;;;22074:17:0;;;::::1;::::0;;;::::1;::::0;;21818:281::o;39143:98::-;39201:7;39228:5;39232:1;39228;:5;:::i;42748:181::-;42804:6;-1:-1:-1;;;42831:5:0;:14;42823:67;;;;-1:-1:-1;;;42823:67:0;;11205:2:1;42823:67:0;;;11187:21:1;11244:2;11224:18;;;11217:30;11283:34;11263:18;;;11256:62;11354:10;11334:18;;;11327:38;11382:19;;42823:67:0;11177:230:1;42823:67:0;-1:-1:-1;42915:5:0;42748:181::o;44181:176::-;44237:6;;44267:5;44271:1;44267;:5;:::i;:::-;44256:16;;44297:1;44292;:6;;:16;;;;;44307:1;44302;:6;;44292:16;44291:38;;;;44318:1;44314;:5;:14;;;;;44327:1;44323;:5;44314:14;44283:47;;;;;44365:127;44421:7;44454:1;44449;:6;;44441:15;;;;;17496:380;-1:-1:-1;;;;;17632:19:0;;17624:68;;;;-1:-1:-1;;;17624:68:0;;10442:2:1;17624:68:0;;;10424:21:1;10481:2;10461:18;;;10454:30;10520:34;10500:18;;;10493:62;10591:6;10571:18;;;10564:34;10615:19;;17624:68:0;10414:226:1;17624:68:0;-1:-1:-1;;;;;17711:21:0;;17703:68;;;;-1:-1:-1;;;17703:68:0;;7292:2:1;17703:68:0;;;7274:21:1;7331:2;7311:18;;;7304:30;7370:34;7350:18;;;7343:62;7441:4;7421:18;;;7414:32;7463:19;;17703:68:0;7264:224:1;17703:68:0;-1:-1:-1;;;;;17784:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;17836:32;;13424:25:1;;;17836:32:0;;13397:18:1;17836:32:0;;;;;;;;17496:380;;;:::o;53499:552::-;-1:-1:-1;;;;;53648:14:0;;;;;;:8;:14;;;;;;53630:15;:32;53622:56;;;;-1:-1:-1;;;53622:56:0;;12374:2:1;53622:56:0;;;12356:21:1;12413:2;12393:18;;;12386:30;-1:-1:-1;;;12432:18:1;;;12425:41;12483:18;;53622:56:0;12346:161:1;53622:56:0;53689:32;53705:4;53711:2;53715:5;53689:15;:32::i;:::-;53734:21;53758:45;:34;53786:5;53758:23;;:27;;:34;;;;:::i;:45::-;-1:-1:-1;;;;;53849:32:0;;;;;;:26;:32;;;;;;53734:69;;-1:-1:-1;53849:76:0;;53734:69;53849:36;:76::i;:::-;-1:-1:-1;;;;;53814:32:0;;;;;;;:26;:32;;;;;;:111;;;;53969:30;;;;;;;:74;;54018:14;53969:34;:74::i;:::-;-1:-1:-1;;;;;53936:30:0;;;;;;;:26;:30;;;;;:107;;;;-1:-1:-1;;;53499:552:0:o;40684:240::-;40804:7;40865:12;40857:6;;;;40849:29;;;;-1:-1:-1;;;40849:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;40900:5:0;;;40684:240::o;54325:274::-;54401:27;54413:7;54422:5;54401:11;:27::i;:::-;54479:112;54543:47;54544:34;54572:5;54544:23;;:27;;:34;;;;:::i;54543:47::-;-1:-1:-1;;;;;54479:59:0;;;;;;:26;:59;;;;;;;:63;:112::i;:::-;-1:-1:-1;;;;;54441:35:0;;;;;;;:26;:35;;;;;:150;;;;-1:-1:-1;54325:274:0:o;38405:98::-;38463:7;38490:5;38494:1;38490;:5;:::i;54882:344::-;-1:-1:-1;;;;;54984:17:0;;;;;;:8;:17;;;;;;54966:15;:35;54958:59;;;;-1:-1:-1;;;54958:59:0;;12374:2:1;54958:59:0;;;12356:21:1;12413:2;12393:18;;;12386:30;-1:-1:-1;;;12432:18:1;;;12425:41;12483:18;;54958:59:0;12346:161:1;54958:59:0;55028:27;55040:7;55049:5;55028:11;:27::i;:::-;55106:112;55170:47;55171:34;55199:5;55171:23;;:27;;:34;;;;:::i;55170:47::-;-1:-1:-1;;;;;55106:59:0;;;;;;:26;:59;;;;;;;:63;:112::i;51864:194::-;-1:-1:-1;;;;;52025:24:0;;51960:7;52025:24;;;:16;:24;;;;;;51992:58;;:28;52042:6;51992:20;:28::i;:::-;:32;;:58::i;20450:129::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5344:101;20508:26:::1;:24;:26::i;:::-;20545;:24;:26::i;:::-;5475:14:::0;5471:68;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;5471:68;20450:129;:::o;8688:204::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5344:101;8809:26:::1;:24;:26::i;:::-;8846:38;8869:5;8876:7;8846:22;:38::i;:::-;5475:14:::0;5471:68;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;5471:68;8688:204;;;:::o;31479:259::-;31661:58;;;-1:-1:-1;;;;;4558:55:1;;31661:58:0;;;4540:74:1;4630:18;;;;4623:34;;;31661:58:0;;;;;;;;;;4513:18:1;;;;31661:58:0;;;;;;;;;;31684:23;31661:58;;;31607:123;;31641:5;;31607:19;:123::i;14931:675::-;-1:-1:-1;;;;;15071:20:0;;15063:70;;;;-1:-1:-1;;;15063:70:0;;10036:2:1;15063:70:0;;;10018:21:1;10075:2;10055:18;;;10048:30;10114:34;10094:18;;;10087:62;10185:7;10165:18;;;10158:35;10210:19;;15063:70:0;10008:227:1;15063:70:0;-1:-1:-1;;;;;15152:23:0;;15144:71;;;;-1:-1:-1;;;15144:71:0;;6078:2:1;15144:71:0;;;6060:21:1;6117:2;6097:18;;;6090:30;6156:34;6136:18;;;6129:62;6227:5;6207:18;;;6200:33;6250:19;;15144:71:0;6050:225:1;15144:71:0;-1:-1:-1;;;;;15312:17:0;;15288:21;15312:17;;;:9;:17;;;;;;15362:23;;;;15340:111;;;;-1:-1:-1;;;15340:111:0;;7695:2:1;15340:111:0;;;7677:21:1;7734:2;7714:18;;;7707:30;7773:34;7753:18;;;7746:62;7844:8;7824:18;;;7817:36;7870:19;;15340:111:0;7667:228:1;15340:111:0;15482:22;15498:6;15482:13;:22;:::i;:::-;-1:-1:-1;;;;;15462:17:0;;;;;;;:9;:17;;;;;;:42;;;;15515:20;;;;;;;;:30;;15539:6;;15462:17;15515:30;;15539:6;;15515:30;:::i;:::-;;;;;;;;15580:9;-1:-1:-1;;;;;15563:35:0;15572:6;-1:-1:-1;;;;;15563:35:0;;15591:6;15563:35;;;;13424:25:1;;13412:2;13397:18;;13379:76;15563:35:0;;;;;;;;14931:675;;;;:::o;44010:163::-;44066:6;44099:1;44094;:6;;:20;;;;-1:-1:-1;44113:1:0;44104:5;44108:1;44113;44104:5;:::i;:::-;:10;;44094:20;44093:46;;;;44124:1;44120;:5;:18;;;;-1:-1:-1;44137:1:0;44129:5;44133:1;44137;44129:5;:::i;:::-;:9;44120:18;44085:55;;;;;;44160:5;44164:1;44160;:5;:::i;15893:338::-;-1:-1:-1;;;;;15977:21:0;;15969:65;;;;-1:-1:-1;;;15969:65:0;;13120:2:1;15969:65:0;;;13102:21:1;13159:2;13139:18;;;13132:30;13198:33;13178:18;;;13171:61;13249:18;;15969:65:0;13092:181:1;15969:65:0;16125:6;16109:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16142:18:0;;;;;;:9;:18;;;;;:28;;16164:6;;16142:18;:28;;16164:6;;16142:28;:::i;:::-;;;;-1:-1:-1;;16186:37:0;;13424:25:1;;;-1:-1:-1;;;;;16186:37:0;;;16203:1;;16186:37;;13412:2:1;13397:18;16186:37:0;;;;;;;15893:338;;:::o;16564:494::-;-1:-1:-1;;;;;16648:21:0;;16640:67;;;;-1:-1:-1;;;16640:67:0;;9634:2:1;16640:67:0;;;9616:21:1;9673:2;9653:18;;;9646:30;9712:34;9692:18;;;9685:62;9783:3;9763:18;;;9756:31;9804:19;;16640:67:0;9606:223:1;16640:67:0;-1:-1:-1;;;;;16807:18:0;;16782:22;16807:18;;;:9;:18;;;;;;16844:24;;;;16836:71;;;;-1:-1:-1;;;16836:71:0;;6482:2:1;16836:71:0;;;6464:21:1;6521:2;6501:18;;;6494:30;6560:34;6540:18;;;6533:62;6631:4;6611:18;;;6604:32;6653:19;;16836:71:0;6454:224:1;16836:71:0;16939:23;16956:6;16939:14;:23;:::i;:::-;-1:-1:-1;;;;;16918:18:0;;;;;;:9;:18;;;;;:44;;;;16973:12;:22;;16989:6;;16918:18;16973:22;;16989:6;;16973:22;:::i;:::-;;;;-1:-1:-1;;17013:37:0;;13424:25:1;;;17039:1:0;;-1:-1:-1;;;;;17013:37:0;;;;;13412:2:1;13397:18;17013:37:0;13379:76:1;38786:98:0;38844:7;38871:5;38875:1;38871;:5;:::i;6305:59::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5471:68;;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;6305:59;:::o;20587:196::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5344:101;20698:6:::1;:18:::0;;-1:-1:-1;;20698:18:0::1;6452:10:::0;20698:18;;::::1;::::0;;;20732:43:::1;::::0;6452:10;;20655:17:::1;::::0;20732:43:::1;::::0;20655:17;;20732:43:::1;5457:1;5475:14:::0;5471:68;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;20587:196;:::o;8900:180::-;5180:13;;;;;;;;:30;;-1:-1:-1;5198:12:0;;;;5197:13;5180:30;5158:126;;;;-1:-1:-1;;;5158:126:0;;8509:2:1;5158:126:0;;;8491:21:1;8548:2;8528:18;;;8521:30;8587:34;8567:18;;;8560:62;-1:-1:-1;;;8638:18:1;;;8631:44;8692:19;;5158:126:0;8481:236:1;5158:126:0;5297:19;5320:13;;;;;;5319:14;5344:101;;;;5379:13;:20;;-1:-1:-1;;5414:19:0;;;;;5344:101;9031:13;;::::1;::::0;:5:::1;::::0;:13:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;9055:17:0;;::::1;::::0;:7:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;;5475:14:::0;5471:68;;;5522:5;5506:21;;-1:-1:-1;;5506:21:0;;;8900:180;;;:::o;34555:885::-;35004:23;35030:106;35072:4;35030:106;;;;;;;;;;;;;;;;;35038:5;-1:-1:-1;;;;;35030:27:0;;;:106;;;;;:::i;:::-;35151:17;;35004:132;;-1:-1:-1;35151:21:0;35147:286;;35324:10;35313:30;;;;;;;;;;;;:::i;:::-;35287:134;;;;-1:-1:-1;;;35287:134:0;;11614:2:1;35287:134:0;;;11596:21:1;11653:2;11633:18;;;11626:30;11692:34;11672:18;;;11665:62;11763:12;11743:18;;;11736:40;11793:19;;35287:134:0;11586:232:1;25932:229:0;26069:12;26101:52;26123:6;26131:4;26137:1;26140:12;26101:21;:52::i;:::-;26094:59;25932:229;-1:-1:-1;;;;25932:229:0:o;27148:632::-;27318:12;27390:5;27365:21;:30;;27343:118;;;;-1:-1:-1;;;27343:118:0;;8102:2:1;27343:118:0;;;8084:21:1;8141:2;8121:18;;;8114:30;8180:34;8160:18;;;8153:62;8251:8;8231:18;;;8224:36;8277:19;;27343:118:0;8074:228:1;27343:118:0;23275:20;;27472:60;;;;-1:-1:-1;;;27472:60:0;;10847:2:1;27472:60:0;;;10829:21:1;10886:2;10866:18;;;10859:30;10925:31;10905:18;;;10898:59;10974:18;;27472:60:0;10819:179:1;27472:60:0;27606:12;27620:23;27647:6;-1:-1:-1;;;;;27647:11:0;27666:5;27687:4;27647:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27605:97;;;;27720:52;27738:7;27747:10;27759:12;27720:17;:52::i;:::-;27713:59;27148:632;-1:-1:-1;;;;;;;27148:632:0:o;30071:777::-;30221:12;30250:7;30246:595;;;-1:-1:-1;30281:10:0;30274:17;;30246:595;30395:17;;:21;30391:439;;30658:10;30652:17;30719:15;30706:10;30702:2;30698:19;30691:44;30606:148;30801:12;30794:20;;-1:-1:-1;;;30794:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:739:1;57:5;110:3;103:4;95:6;91:17;87:27;77:2;;132:5;125;118:20;77:2;172:6;159:20;198:18;235:2;231;228:10;225:2;;;241:18;;:::i;:::-;316:2;310:9;284:2;370:13;;-1:-1:-1;;366:22:1;;;390:2;362:31;358:40;346:53;;;414:18;;;434:22;;;411:46;408:2;;;460:18;;:::i;:::-;500:10;496:2;489:22;535:2;527:6;520:18;581:3;574:4;569:2;561:6;557:15;553:26;550:35;547:2;;;602:5;595;588:20;547:2;670;663:4;655:6;651:17;644:4;636:6;632:17;619:54;693:15;;;710:4;689:26;682:41;;;;-1:-1:-1;697:6:1;67:686;-1:-1:-1;;;67:686:1:o;758:257::-;817:6;870:2;858:9;849:7;845:23;841:32;838:2;;;891:6;883;876:22;838:2;935:9;922:23;954:31;979:5;954:31;:::i;1020:398::-;1088:6;1096;1149:2;1137:9;1128:7;1124:23;1120:32;1117:2;;;1170:6;1162;1155:22;1117:2;1214:9;1201:23;1233:31;1258:5;1233:31;:::i;:::-;1283:5;-1:-1:-1;1340:2:1;1325:18;;1312:32;1353:33;1312:32;1353:33;:::i;:::-;1405:7;1395:17;;;1107:311;;;;;:::o;1423:466::-;1500:6;1508;1516;1569:2;1557:9;1548:7;1544:23;1540:32;1537:2;;;1590:6;1582;1575:22;1537:2;1634:9;1621:23;1653:31;1678:5;1653:31;:::i;:::-;1703:5;-1:-1:-1;1760:2:1;1745:18;;1732:32;1773:33;1732:32;1773:33;:::i;:::-;1527:362;;1825:7;;-1:-1:-1;;;1879:2:1;1864:18;;;;1851:32;;1527:362::o;1894:325::-;1962:6;1970;2023:2;2011:9;2002:7;1998:23;1994:32;1991:2;;;2044:6;2036;2029:22;1991:2;2088:9;2075:23;2107:31;2132:5;2107:31;:::i;:::-;2157:5;2209:2;2194:18;;;;2181:32;;-1:-1:-1;;;1981:238:1:o;2224:393::-;2301:6;2309;2317;2370:2;2358:9;2349:7;2345:23;2341:32;2338:2;;;2391:6;2383;2376:22;2338:2;2435:9;2422:23;2454:31;2479:5;2454:31;:::i;:::-;2504:5;2556:2;2541:18;;2528:32;;-1:-1:-1;2607:2:1;2592:18;;;2579:32;;2328:289;-1:-1:-1;;;2328:289:1:o;2622:297::-;2689:6;2742:2;2730:9;2721:7;2717:23;2713:32;2710:2;;;2763:6;2755;2748:22;2710:2;2800:9;2794:16;2853:5;2846:13;2839:21;2832:5;2829:32;2819:2;;2880:6;2872;2865:22;2924:732;3045:6;3053;3061;3114:2;3102:9;3093:7;3089:23;3085:32;3082:2;;;3135:6;3127;3120:22;3082:2;3179:9;3166:23;3198:31;3223:5;3198:31;:::i;:::-;3248:5;-1:-1:-1;3304:2:1;3289:18;;3276:32;3327:18;3357:14;;;3354:2;;;3389:6;3381;3374:22;3354:2;3417:50;3459:7;3450:6;3439:9;3435:22;3417:50;:::i;:::-;3407:60;;3520:2;3509:9;3505:18;3492:32;3476:48;;3549:2;3539:8;3536:16;3533:2;;;3570:6;3562;3555:22;3533:2;;3598:52;3642:7;3631:8;3620:9;3616:24;3598:52;:::i;:::-;3588:62;;;3072:584;;;;;:::o;3661:190::-;3720:6;3773:2;3761:9;3752:7;3748:23;3744:32;3741:2;;;3794:6;3786;3779:22;3741:2;-1:-1:-1;3822:23:1;;3731:120;-1:-1:-1;3731:120:1:o;3856:274::-;3985:3;4023:6;4017:13;4039:53;4085:6;4080:3;4073:4;4065:6;4061:17;4039:53;:::i;:::-;4108:16;;;;;3993:137;-1:-1:-1;;3993:137:1:o;5488:383::-;5637:2;5626:9;5619:21;5600:4;5669:6;5663:13;5712:6;5707:2;5696:9;5692:18;5685:34;5728:66;5787:6;5782:2;5771:9;5767:18;5762:2;5754:6;5750:15;5728:66;:::i;:::-;5855:2;5834:15;-1:-1:-1;;5830:29:1;5815:45;;;;5862:2;5811:54;;5609:262;-1:-1:-1;;5609:262:1:o;13649:369::-;13688:3;13723;13720:1;13716:11;13834:1;13766:66;13762:74;13759:1;13755:82;13750:2;13743:10;13739:99;13736:2;;;13841:18;;:::i;:::-;13960:1;-1:-1:-1;;;13888:74:1;13885:1;13881:82;13877:2;13873:91;13870:2;;;13967:18;;:::i;:::-;-1:-1:-1;;14003:9:1;;13696:322::o;14023:128::-;14063:3;14094:1;14090:6;14087:1;14084:13;14081:2;;;14100:18;;:::i;:::-;-1:-1:-1;14136:9:1;;14071:80::o;14156:274::-;14196:1;14222;14212:2;;-1:-1:-1;;;14254:1:1;14247:88;14358:4;14355:1;14348:15;14386:4;14383:1;14376:15;14212:2;-1:-1:-1;14415:9:1;;14202:228::o;14435:168::-;14475:7;14541:1;14537;14533:6;14529:14;14526:1;14523:21;14518:1;14511:9;14504:17;14500:45;14497:2;;;14548:18;;:::i;:::-;-1:-1:-1;14588:9:1;;14487:116::o;14608:372::-;14647:4;14683;14680:1;14676:12;14795:1;-1:-1:-1;;;14723:74:1;14720:1;14716:82;14711:2;14704:10;14700:99;14697:2;;;14802:18;;:::i;:::-;14921:1;14853:66;14849:74;14846:1;14842:82;14838:2;14834:91;14831:2;;;14928:18;;:::i;:::-;-1:-1:-1;;14965:9:1;;14656:324::o;14985:125::-;15025:4;15053:1;15050;15047:8;15044:2;;;15058:18;;:::i;:::-;-1:-1:-1;15095:9:1;;15034:76::o;15115:258::-;15187:1;15197:113;15211:6;15208:1;15205:13;15197:113;;;15287:11;;;15281:18;15268:11;;;15261:39;15233:2;15226:10;15197:113;;;15328:6;15325:1;15322:13;15319:2;;;-1:-1:-1;;15363:1:1;15345:16;;15338:27;15168:205::o;15378:437::-;15457:1;15453:12;;;;15500;;;15521:2;;15575:4;15567:6;15563:17;15553:27;;15521:2;15628;15620:6;15617:14;15597:18;15594:38;15591:2;;;-1:-1:-1;;;15662:1:1;15655:88;15766:4;15763:1;15756:15;15794:4;15791:1;15784:15;15591:2;;15433:382;;;:::o;15820:184::-;-1:-1:-1;;;15869:1:1;15862:88;15969:4;15966:1;15959:15;15993:4;15990:1;15983:15;16009:184;-1:-1:-1;;;16058:1:1;16051:88;16158:4;16155:1;16148:15;16182:4;16179:1;16172:15;16198:154;-1:-1:-1;;;;;16277:5:1;16273:54;16266:5;16263:65;16253:2;;16342:1;16339;16332:12
Swarm Source
ipfs://de74982ffe33f8961ccc77136fd94d697cdb619be852865bd346cb10c298fc8a
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.