More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 512 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 59921702 | 197 days ago | IN | 0 POL | 0.00394158 | ||||
Deposit | 26949450 | 1038 days ago | IN | 0 POL | 0.00377352 | ||||
Withdraw | 24303142 | 1109 days ago | IN | 0 POL | 0.00015553 | ||||
Withdraw | 18617042 | 1259 days ago | IN | 0 POL | 0.00115818 | ||||
Deposit | 18541070 | 1261 days ago | IN | 0 POL | 0.00204331 | ||||
Withdraw | 18488695 | 1263 days ago | IN | 0 POL | 0.00014437 | ||||
Deposit | 18488618 | 1263 days ago | IN | 0 POL | 0.00034221 | ||||
Deposit | 18287482 | 1268 days ago | IN | 0 POL | 0.00016507 | ||||
Withdraw | 18201888 | 1271 days ago | IN | 0 POL | 0.00360912 | ||||
Deposit | 18201850 | 1271 days ago | IN | 0 POL | 0.00031336 | ||||
Deposit | 18169422 | 1271 days ago | IN | 0 POL | 0.0002244 | ||||
Deposit | 18154138 | 1272 days ago | IN | 0 POL | 0.00013397 | ||||
Deposit | 18072456 | 1274 days ago | IN | 0 POL | 0.00013397 | ||||
Deposit | 18013173 | 1276 days ago | IN | 0 POL | 0.00011687 | ||||
Deposit | 18011135 | 1276 days ago | IN | 0 POL | 0.0001466 | ||||
Deposit | 17955749 | 1277 days ago | IN | 0 POL | 0.00036033 | ||||
Deposit | 17955514 | 1277 days ago | IN | 0 POL | 0.00118892 | ||||
Deposit | 17955514 | 1277 days ago | IN | 0 POL | 0.00020723 | ||||
Deposit | 17955514 | 1277 days ago | IN | 0 POL | 0.00023375 | ||||
Deposit | 17948545 | 1277 days ago | IN | 0 POL | 0.00048393 | ||||
Deposit | 17909980 | 1279 days ago | IN | 0 POL | 0.00018439 | ||||
Deposit | 17909868 | 1279 days ago | IN | 0 POL | 0.00017531 | ||||
Deposit | 17898615 | 1279 days ago | IN | 0 POL | 0.00012305 | ||||
Deposit | 17898487 | 1279 days ago | IN | 0 POL | 0.00011699 | ||||
Deposit | 17896269 | 1279 days ago | IN | 0 POL | 0.00011687 |
Loading...
Loading
Contract Name:
MasterChef
Compiler Version
v0.8.0+commit.c7dfd78e
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2021-07-26 */ pragma solidity ^0.8.0; // SPDX-License-Identifier: MIT // 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 SafeMath { /** * @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 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); } /** * @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; 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"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev 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"); (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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } /** * @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 SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 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( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 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( IERC20 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(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } /* * @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; } } /** * @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); } } /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } /** * @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); } /** * @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; address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD; /** * @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"); require(account != BURN_ADDRESS, "ERC20: burn from the zero address"); _beforeTokenTransfer(account, BURN_ADDRESS, amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, BURN_ADDRESS, amount); _afterTokenTransfer(account, BURN_ADDRESS, 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 {} } /** * @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); } } contract XenoToken is ERC20, Ownable, ERC20Burnable { using SafeMath for uint256; uint256 private _cap; constructor(uint256 nCap) ERC20("Xeno Token", "XENO") { require(nCap > 0, "XenoCapped: cap is 0"); _cap = nCap; // Setup LP pools wtih 100 tokens _mint(msg.sender, 100000000000000000000); } /// @dev Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef). function mint(address _to, uint256 _amount) public onlyOwner { require(ERC20.totalSupply() + _amount <= cap(), "XenoCapped: cap exceeded"); _mint(_to, _amount); _moveDelegates(address(0), _delegates[_to], _amount); } // Copied and modified from YAM code: // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol // Which is copied and modified from COMPOUND: // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol /// @dev A record of each accounts delegate mapping (address => address) internal _delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint256 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /** * @dev Returns the cap on the token's total supply. */ function cap() public view returns (uint256) { return _cap; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegator The address to get delegatee for */ function delegates(address delegator) external view returns (address) { return _delegates[delegator]; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) external { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig( address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s ) external { bytes32 domainSeparator = keccak256( abi.encode( DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this) ) ); bytes32 structHash = keccak256( abi.encode( DELEGATION_TYPEHASH, delegatee, nonce, expiry ) ); bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", domainSeparator, structHash ) ); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "EGG::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "EGG::delegateBySig: invalid nonce"); require(block.timestamp <= expiry, "EGG::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint256) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) external view returns (uint256) { require(blockNumber < block.number, "EGG::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = _delegates[delegator]; uint256 delegatorBalance = balanceOf(delegator); // balance of underlying EGGs (not scaled); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { // decrease old representative uint32 srcRepNum = numCheckpoints[srcRep]; uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint256 srcRepNew = srcRepOld.sub(amount); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { // increase new representative uint32 dstRepNum = numCheckpoints[dstRep]; uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint256 dstRepNew = dstRepOld.add(amount); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32(block.number, "EGG::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function getChainId() internal view returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } // MasterChef is the master of Xeno. He can make Xeno and he is a fair guy. // // Note that it's ownable and the owner wields tremendous power. The ownership // will be transferred to a governance smart contract once Xeno is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless. contract MasterChef is Ownable, ReentrancyGuard { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of Xenos // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accXenoPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accXenoPerShare` (and `lastRewardBlock`) gets updated. // 2. User receives the pending reward sent to his/her address. // 3. User's `amount` gets updated. // 4. User's `rewardDebt` gets updated. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. uint256 allocPoint; // How many allocation points assigned to this pool. Xenos to distribute per block. uint256 lastRewardBlock; // Last block number that Xenos distribution occurs. uint256 accXenoPerShare; // Accumulated Xenos per share, times 1e12. See below. uint16 depositFeeBP; // Deposit fee in basis points } // The Xeno TOKEN! XenoToken public xeno; // Dev address. address public devaddr; // Xeno tokens created per block. uint256 public xenoPerBlock; // Bonus muliplier for early xeno makers. uint256 public constant BONUS_MULTIPLIER = 1; // Deposit Fee address address public feeAddress; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Total allocation points. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when Xeno mining starts. uint256 public startBlock; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); event SetFeeAddress(address indexed user, address indexed newAddress); event SetDevAddress(address indexed user, address indexed newAddress); event UpdateEmissionRate(address indexed user, uint256 xenoPerBlock); constructor( XenoToken _xeno, address _devaddr, address _feeAddress, uint256 _xenoPerBlock, uint256 _startBlock ) public { xeno = _xeno; devaddr = _devaddr; feeAddress = _feeAddress; xenoPerBlock = _xenoPerBlock; startBlock = _startBlock; } function poolLength() external view returns (uint256) { return poolInfo.length; } mapping(IERC20 => bool) public poolExistence; modifier nonDuplicated(IERC20 _lpToken) { require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated"); _; } // Add a new lp to the pool. Can only be called by the owner. function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, bool _withUpdate) public onlyOwner nonDuplicated(_lpToken) { require(_depositFeeBP <= 600, "add: invalid deposit fee basis points"); // Max 6% if (_withUpdate) { massUpdatePools(); } uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolExistence[_lpToken] = true; poolInfo.push(PoolInfo({ lpToken : _lpToken, allocPoint : _allocPoint, lastRewardBlock : lastRewardBlock, accXenoPerShare : 0, depositFeeBP : _depositFeeBP })); } // Update the given pool's Xeno allocation point and deposit fee. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, bool _withUpdate) public onlyOwner { require(_depositFeeBP <= 600, "set: invalid deposit fee basis points"); if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; poolInfo[_pid].depositFeeBP = _depositFeeBP; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { return _to.sub(_from).mul(BONUS_MULTIPLIER); } // View function to see pending Xenos on frontend. function pendingXeno(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accXenoPerShare = pool.accXenoPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 xenoReward = multiplier.mul(xenoPerBlock).mul(pool.allocPoint).div(totalAllocPoint); accXenoPerShare = accXenoPerShare.add(xenoReward.mul(1e12).div(lpSupply)); } return user.amount.mul(accXenoPerShare).div(1e12).sub(user.rewardDebt); } // Update reward variables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } // Update reward variables of the given pool to be up-to-date. function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0 || pool.allocPoint == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 xenoReward = multiplier.mul(xenoPerBlock).mul(pool.allocPoint).div(totalAllocPoint); xeno.mint(devaddr, xenoReward.div(10)); xeno.mint(address(this), xenoReward); pool.accXenoPerShare = pool.accXenoPerShare.add(xenoReward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to MasterChef for Xeno allocation. function deposit(uint256 _pid, uint256 _amount) public nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accXenoPerShare).div(1e12).sub(user.rewardDebt); if (pending > 0) { safeXenoTransfer(msg.sender, pending); } } if (_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); if (pool.depositFeeBP > 0) { uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000); pool.lpToken.safeTransfer(feeAddress, depositFee); user.amount = user.amount.add(_amount).sub(depositFee); } else { user.amount = user.amount.add(_amount); } } user.rewardDebt = user.amount.mul(pool.accXenoPerShare).div(1e12); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from MasterChef. function withdraw(uint256 _pid, uint256 _amount) public nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accXenoPerShare).div(1e12).sub(user.rewardDebt); if (pending > 0) { safeXenoTransfer(msg.sender, pending); } if (_amount > 0) { user.amount = user.amount.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); } user.rewardDebt = user.amount.mul(pool.accXenoPerShare).div(1e12); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint256 amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), amount); emit EmergencyWithdraw(msg.sender, _pid, amount); } // Safe xeno transfer function, just in case if rounding error causes pool to not have enough Xenos. function safeXenoTransfer(address _to, uint256 _amount) internal { uint256 xenoBal = xeno.balanceOf(address(this)); bool transferSuccess = false; if (_amount > xenoBal) { transferSuccess = xeno.transfer(_to, xenoBal); } else { transferSuccess = xeno.transfer(_to, _amount); } require(transferSuccess, "safeXenoTransfer: transfer failed"); } // Update dev address by the previous dev. function dev(address _devaddr) public { require(msg.sender == devaddr, "dev: wut?"); devaddr = _devaddr; emit SetDevAddress(msg.sender, _devaddr); } function setFeeAddress(address _feeAddress) public { require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN"); feeAddress = _feeAddress; emit SetFeeAddress(msg.sender, _feeAddress); } //Pancake has to add hidden dummy pools inorder to alter the emission, here we make it simple and transparent to all. function updateEmissionRate(uint256 _xenoPerBlock) public onlyOwner { massUpdatePools(); xenoPerBlock = _xenoPerBlock; emit UpdateEmissionRate(msg.sender, _xenoPerBlock); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract XenoToken","name":"_xeno","type":"address"},{"internalType":"address","name":"_devaddr","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"uint256","name":"_xenoPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","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":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"xenoPerBlock","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devaddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingXeno","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accXenoPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_xenoPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xeno","outputs":[{"internalType":"contract XenoToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xenoPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000063bdb72ba6320a8cac5e84734db4f0dfb7b35fb0000000000000000000000000bc5daf8bcd482ef62d3977dc93c35740d51dd53300000000000000000000000011f7ff9be8195cbb144d368b3742fc714c9570b8000000000000000000000000000000000000000000000000011c37937e08000000000000000000000000000000000000000000000000000000000000010eb02a
-----Decoded View---------------
Arg [0] : _xeno (address): 0x63bDB72ba6320A8cAc5e84734Db4F0DFb7b35FB0
Arg [1] : _devaddr (address): 0xBC5dAf8bCD482EF62d3977DC93c35740d51Dd533
Arg [2] : _feeAddress (address): 0x11F7Ff9BE8195CbB144d368B3742Fc714c9570B8
Arg [3] : _xenoPerBlock (uint256): 80000000000000000
Arg [4] : _startBlock (uint256): 17739818
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000063bdb72ba6320a8cac5e84734db4f0dfb7b35fb0
Arg [1] : 000000000000000000000000bc5daf8bcd482ef62d3977dc93c35740d51dd533
Arg [2] : 00000000000000000000000011f7ff9be8195cbb144d368b3742fc714c9570b8
Arg [3] : 000000000000000000000000000000000000000000000000011c37937e080000
Arg [4] : 00000000000000000000000000000000000000000000000000000000010eb02a
Deployed Bytecode Sourcemap
50511:10610:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53516:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60914:204;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52325:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;52566:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52264:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58556:755;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52657:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56558:805;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59382:398;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56302:180;;;:::i;:::-;;51987:21;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23604:94;;;:::i;:::-;;53886:718;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60563:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52185:44;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60375:180;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22953:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55253:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52407:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;55460:759;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53619:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52036:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54716:461;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57432:1072;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;23853:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52104:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53516:95;53561:7;53588:8;:15;;;;53581:22;;53516:95;:::o;60914:204::-;23184:12;:10;:12::i;:::-;23173:23;;:7;:5;:7::i;:::-;:23;;;23165:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60993:17:::1;:15;:17::i;:::-;61036:13;61021:12;:28;;;;61084:10;61065:45;;;61096:13;61065:45;;;;;;:::i;:::-;;;;;;;;60914:204:::0;:::o;52325:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;52566:34::-;;;;:::o;52264:25::-;;;;;;;;;;;;;:::o;58556:755::-;25884:1;26480:7;;:19;;26472:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;25884:1;26613:7;:18;;;;58636:21:::1;58660:8;58669:4;58660:14;;;;;;;;;;;;;;;;;;;;;;;;;;58636:38;;58685:21;58709:8;:14;58718:4;58709:14;;;;;;;;;;;:26;58724:10;58709:26;;;;;;;;;;;;;;;58685:50;;58769:7;58754:4;:11;;;:22;;58746:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;58810:16;58821:4;58810:10;:16::i;:::-;58837:15;58855:68;58907:4;:15;;;58855:47;58897:4;58855:37;58871:4;:20;;;58855:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:68;;;;:::i;:::-;58837:86;;58948:1;58938:7;:11;58934:81;;;58966:37;58983:10;58995:7;58966:16;:37::i;:::-;58934:81;59039:1;59029:7;:11;59025:152;;;59071:24;59087:7;59071:4;:11;;;:15;;:24;;;;:::i;:::-;59057:4;:11;;:38;;;;59110:55;59144:10;59157:7;59110:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;59025:152;59205:47;59247:4;59205:37;59221:4;:20;;;59205:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;59187:4;:15;;:65;;;;59289:4;59277:10;59268:35;;;59295:7;59268:35;;;;;;:::i;:::-;;;;;;;;26644:1;;;25840::::0;26792:7;:22;;;;58556:755;;:::o;52657:25::-;;;;:::o;56558:805::-;56610:21;56634:8;56643:4;56634:14;;;;;;;;;;;;;;;;;;;;;;;;;;56610:38;;56679:4;:20;;;56663:12;:36;56659:75;;56716:7;;;56659:75;56744:16;56763:4;:12;;;;;;;;;;;;:22;;;56794:4;56763:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56744:56;;56827:1;56815:8;:13;:37;;;;56851:1;56832:4;:15;;;:20;56815:37;56811:126;;;56892:12;56869:4;:20;;:35;;;;56919:7;;;;56811:126;56947:18;56968:49;56982:4;:20;;;57004:12;56968:13;:49::i;:::-;56947:70;;57028:18;57049:70;57103:15;;57049:49;57082:4;:15;;;57049:28;57064:12;;57049:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;57028:91;;57130:4;;;;;;;;;;;:9;;;57140:7;;;;;;;;;;;57149:18;57164:2;57149:10;:14;;:18;;;;:::i;:::-;57130:38;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57179:4;;;;;;;;;;;:9;;;57197:4;57204:10;57179:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57249:60;57274:34;57299:8;57274:20;57289:4;57274:10;:14;;:20;;;;:::i;:::-;:24;;:34;;;;:::i;:::-;57249:4;:20;;;:24;;:60;;;;:::i;:::-;57226:4;:20;;:83;;;;57343:12;57320:4;:20;;:35;;;;56558:805;;;;;;:::o;59382:398::-;25884:1;26480:7;;:19;;26472:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;25884:1;26613:7;:18;;;;59454:21:::1;59478:8;59487:4;59478:14;;;;;;;;;;;;;;;;;;;;;;;;;;59454:38;;59503:21;59527:8;:14;59536:4;59527:14;;;;;;;;;;;:26;59542:10;59527:26;;;;;;;;;;;;;;;59503:50;;59564:14;59581:4;:11;;;59564:28;;59617:1;59603:4;:11;;:15;;;;59647:1;59629:4;:15;;:19;;;;59659:54;59693:10;59706:6;59659:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;59759:4;59747:10;59729:43;;;59765:6;59729:43;;;;;;:::i;:::-;;;;;;;;26644:1;;;25840::::0;26792:7;:22;;;;59382:398;:::o;56302:180::-;56347:14;56364:8;:15;;;;56347:32;;56395:11;56390:85;56418:6;56412:3;:12;56390:85;;;56448:15;56459:3;56448:10;:15::i;:::-;56426:5;;;;:::i;:::-;;;56390:85;;;;56302:180;:::o;51987:21::-;;;;;;;;;;;;;:::o;23604:94::-;23184:12;:10;:12::i;:::-;23173:23;;:7;:5;:7::i;:::-;:23;;;23165:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23669:21:::1;23687:1;23669:9;:21::i;:::-;23604:94::o:0;53886:718::-;23184:12;:10;:12::i;:::-;23173:23;;:7;:5;:7::i;:::-;:23;;;23165:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54008:8:::1;53756:5;53729:32;;:13;:23;53743:8;53729:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;53721:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;54054:3:::2;54037:13;:20;;;;54029:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;54124:11;54120:61;;;54152:17;:15;:17::i;:::-;54120:61;54191:23;54232:10;;54217:12;:25;:53;;54260:10;;54217:53;;;54245:12;54217:53;54191:79;;54299:32;54319:11;54299:15;;:19;;:32;;;;:::i;:::-;54281:15;:50;;;;54368:4;54342:13;:23;54356:8;54342:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;54383:8;54397:198;;;;;;;;54427:8;54397:198;;;;;;54459:11;54397:198;;;;54499:15;54397:198;;;;54543:1;54397:198;;;;54570:13;54397:198;;;;::::0;54383:213:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53802:1;23244::::1;53886:718:::0;;;;:::o;60563:220::-;60647:10;;;;;;;;;;;60633:24;;:10;:24;;;60625:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;60710:11;60697:10;;:24;;;;;;;;;;;;;;;;;;60763:11;60737:38;;60751:10;60737:38;;;;;;;;;;;;60563:220;:::o;52185:44::-;52228:1;52185:44;:::o;60375:180::-;60446:7;;;;;;;;;;;60432:21;;:10;:21;;;60424:43;;;;;;;;;;;;:::i;:::-;;;;;;;;;60488:8;60478:7;;:18;;;;;;;;;;;;;;;;;;60538:8;60512:35;;60526:10;60512:35;;;;;;;;;;;;60375:180;:::o;22953:87::-;22999:7;23026:6;;;;;;;;;;;23019:13;;22953:87;:::o;55253:143::-;55325:7;55352:36;52228:1;55352:14;55360:5;55352:3;:7;;:14;;;;:::i;:::-;:18;;:36;;;;:::i;:::-;55345:43;;55253:143;;;;:::o;52407:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55460:759::-;55533:7;55553:21;55577:8;55586:4;55577:14;;;;;;;;;;;;;;;;;;;;;;;;;;55553:38;;55602:21;55626:8;:14;55635:4;55626:14;;;;;;;;;;;:21;55641:5;55626:21;;;;;;;;;;;;;;;55602:45;;55658:23;55684:4;:20;;;55658:46;;55715:16;55734:4;:12;;;;;;;;;;;;:22;;;55765:4;55734:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55715:56;;55801:4;:20;;;55786:12;:35;:52;;;;;55837:1;55825:8;:13;;55786:52;55782:349;;;55855:18;55876:49;55890:4;:20;;;55912:12;55876:13;:49::i;:::-;55855:70;;55940:18;55961:70;56015:15;;55961:49;55994:4;:15;;;55961:28;55976:12;;55961:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;55940:91;;56064:55;56084:34;56109:8;56084:20;56099:4;56084:10;:14;;:20;;;;:::i;:::-;:24;;:34;;;;:::i;:::-;56064:15;:19;;:55;;;;:::i;:::-;56046:73;;55782:349;;;56148:63;56195:4;:15;;;56148:42;56185:4;56148:32;56164:15;56148:4;:11;;;:15;;:32;;;;:::i;:::-;:36;;:42;;;;:::i;:::-;:46;;:63;;;;:::i;:::-;56141:70;;;;;;55460:759;;;;:::o;53619:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;52036:22::-;;;;;;;;;;;;;:::o;54716:461::-;23184:12;:10;:12::i;:::-;23173:23;;:7;:5;:7::i;:::-;:23;;;23165:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54857:3:::1;54840:13;:20;;;;54832:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;54917:11;54913:61;;;54945:17;:15;:17::i;:::-;54913:61;55002:63;55053:11;55002:46;55022:8;55031:4;55022:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;55002:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;54984:15;:81;;;;55104:11;55076:8;55085:4;55076:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;55156:13;55126:8;55135:4;55126:14;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;54716:461:::0;;;;:::o;57432:1072::-;25884:1;26480:7;;:19;;26472:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;25884:1;26613:7;:18;;;;57511:21:::1;57535:8;57544:4;57535:14;;;;;;;;;;;;;;;;;;;;;;;;;;57511:38;;57560:21;57584:8;:14;57593:4;57584:14;;;;;;;;;;;:26;57599:10;57584:26;;;;;;;;;;;;;;;57560:50;;57621:16;57632:4;57621:10;:16::i;:::-;57666:1;57652:4;:11;;;:15;57648:237;;;57684:15;57702:68;57754:4;:15;;;57702:47;57744:4;57702:37;57718:4;:20;;;57702:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:68;;;;:::i;:::-;57684:86;;57799:1;57789:7;:11;57785:89;;;57821:37;57838:10;57850:7;57821:16;:37::i;:::-;57785:89;57648:237;;57909:1;57899:7;:11;57895:476;;;57927:74;57965:10;57986:4;57993:7;57927:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;58040:1;58020:4;:17;;;;;;;;;;;;:21;;;58016:344;;;58062:18;58083:41;58118:5;58083:30;58095:4;:17;;;;;;;;;;;;58083:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;58062:62;;58143:49;58169:10;;;;;;;;;;;58181;58143:4;:12;;;;;;;;;;;;:25;;;;:49;;;;;:::i;:::-;58225:40;58254:10;58225:24;58241:7;58225:4;:11;;;:15;;:24;;;;:::i;:::-;:28;;:40;;;;:::i;:::-;58211:4;:11;;:54;;;;58016:344;;;;58320:24;58336:7;58320:4;:11;;;:15;;:24;;;;:::i;:::-;58306:4;:11;;:38;;;;58016:344;57895:476;58399:47;58441:4;58399:37;58415:4;:20;;;58399:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;58381:4;:15;;:65;;;;58482:4;58470:10;58462:34;;;58488:7;58462:34;;;;;;:::i;:::-;;;;;;;;26644:1;;25840::::0;26792:7;:22;;;;57432:1072;;:::o;23853:192::-;23184:12;:10;:12::i;:::-;23173:23;;:7;:5;:7::i;:::-;:23;;;23165:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23962:1:::1;23942:22;;:8;:22;;;;23934:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;24018:19;24028:8;24018:9;:19::i;:::-;23853:192:::0;:::o;52104:27::-;;;;:::o;21829:98::-;21882:7;21909:10;21902:17;;21829:98;:::o;3499:::-;3557:7;3588:1;3584;:5;;;;:::i;:::-;3577:12;;3499:98;;;;:::o;3898:::-;3956:7;3987:1;3983;:5;;;;:::i;:::-;3976:12;;3898:98;;;;:::o;3142:::-;3200:7;3231:1;3227;:5;;;;:::i;:::-;3220:12;;3142:98;;;;:::o;59894:425::-;59970:15;59988:4;;;;;;;;;;;:14;;;60011:4;59988:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59970:47;;60028:20;60081:7;60071;:17;60067:173;;;60123:4;;;;;;;;;;;:13;;;60137:3;60142:7;60123:27;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60105:45;;60067:173;;;60201:4;;;;;;;;;;;:13;;;60215:3;60220:7;60201:27;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60183:45;;60067:173;60258:15;60250:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;59894:425;;;;:::o;17994:211::-;18111:86;18131:5;18161:23;;;18186:2;18190:5;18138:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18111:19;:86::i;:::-;17994:211;;;:::o;2761:98::-;2819:7;2850:1;2846;:5;;;;:::i;:::-;2839:12;;2761:98;;;;:::o;24053:173::-;24109:16;24128:6;;;;;;;;;;;24109:25;;24154:8;24145:6;;:17;;;;;;;;;;;;;;;;;;24209:8;24178:40;;24199:8;24178:40;;;;;;;;;;;;24053:173;;:::o;18213:248::-;18357:96;18377:5;18407:27;;;18436:4;18442:2;18446:5;18384:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18357:19;:96::i;:::-;18213:248;;;;:::o;20567:716::-;20991:23;21017:69;21045:4;21017:69;;;;;;;;;;;;;;;;;21025:5;21017:27;;;;:69;;;;;:::i;:::-;20991:95;;21121:1;21101:10;:17;:21;21097:179;;;21198:10;21187:30;;;;;;;;;;;;:::i;:::-;21179:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;21097:179;20567:716;;;:::o;13160:229::-;13297:12;13329:52;13351:6;13359:4;13365:1;13368:12;13329:21;:52::i;:::-;13322:59;;13160:229;;;;;:::o;14280:511::-;14450:12;14508:5;14483:21;:30;;14475:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;14575:18;14586:6;14575:10;:18::i;:::-;14567:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;14641:12;14655:23;14682:6;:11;;14701:5;14708:4;14682:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14640:73;;;;14731:52;14749:7;14758:10;14770:12;14731:17;:52::i;:::-;14724:59;;;;14280:511;;;;;;:::o;10354:387::-;10414:4;10622:12;10689:7;10677:20;10669:28;;10732:1;10725:4;:8;10718:15;;;10354:387;;;:::o;16749:712::-;16899:12;16928:7;16924:530;;;16959:10;16952:17;;;;16924:530;17093:1;17073:10;:17;:21;17069:374;;;17271:10;17265:17;17332:15;17319:10;17315:2;17311:19;17304:44;17219:148;17414:12;17407:20;;;;;;;;;;;:::i;:::-;;;;;;;;16749:712;;;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:133::-;;233:6;220:20;211:29;;249:30;273:5;249:30;:::i;:::-;201:84;;;;:::o;291:137::-;;376:6;370:13;361:22;;392:30;416:5;392:30;:::i;:::-;351:77;;;;:::o;434:167::-;;532:6;519:20;510:29;;548:47;589:5;548:47;:::i;:::-;500:101;;;;:::o;607:137::-;;690:6;677:20;668:29;;706:32;732:5;706:32;:::i;:::-;658:86;;;;:::o;750:139::-;;834:6;821:20;812:29;;850:33;877:5;850:33;:::i;:::-;802:87;;;;:::o;895:143::-;;983:6;977:13;968:22;;999:33;1026:5;999:33;:::i;:::-;958:80;;;;:::o;1044:262::-;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1168:1;1165;1158:12;1120:2;1211:1;1236:53;1281:7;1272:6;1261:9;1257:22;1236:53;:::i;:::-;1226:63;;1182:117;1110:196;;;;:::o;1312:278::-;;1428:2;1416:9;1407:7;1403:23;1399:32;1396:2;;;1444:1;1441;1434:12;1396:2;1487:1;1512:61;1565:7;1556:6;1545:9;1541:22;1512:61;:::i;:::-;1502:71;;1458:125;1386:204;;;;:::o;1596:290::-;;1718:2;1706:9;1697:7;1693:23;1689:32;1686:2;;;1734:1;1731;1724:12;1686:2;1777:1;1802:67;1861:7;1852:6;1841:9;1837:22;1802:67;:::i;:::-;1792:77;;1748:131;1676:210;;;;:::o;1892:262::-;;2000:2;1988:9;1979:7;1975:23;1971:32;1968:2;;;2016:1;2013;2006:12;1968:2;2059:1;2084:53;2129:7;2120:6;2109:9;2105:22;2084:53;:::i;:::-;2074:63;;2030:117;1958:196;;;;:::o;2160:284::-;;2279:2;2267:9;2258:7;2254:23;2250:32;2247:2;;;2295:1;2292;2285:12;2247:2;2338:1;2363:64;2419:7;2410:6;2399:9;2395:22;2363:64;:::i;:::-;2353:74;;2309:128;2237:207;;;;:::o;2450:407::-;;;2575:2;2563:9;2554:7;2550:23;2546:32;2543:2;;;2591:1;2588;2581:12;2543:2;2634:1;2659:53;2704:7;2695:6;2684:9;2680:22;2659:53;:::i;:::-;2649:63;;2605:117;2761:2;2787:53;2832:7;2823:6;2812:9;2808:22;2787:53;:::i;:::-;2777:63;;2732:118;2533:324;;;;;:::o;2863:718::-;;;;;3032:3;3020:9;3011:7;3007:23;3003:33;3000:2;;;3049:1;3046;3039:12;3000:2;3092:1;3117:53;3162:7;3153:6;3142:9;3138:22;3117:53;:::i;:::-;3107:63;;3063:117;3219:2;3245:67;3304:7;3295:6;3284:9;3280:22;3245:67;:::i;:::-;3235:77;;3190:132;3361:2;3387:52;3431:7;3422:6;3411:9;3407:22;3387:52;:::i;:::-;3377:62;;3332:117;3488:2;3514:50;3556:7;3547:6;3536:9;3532:22;3514:50;:::i;:::-;3504:60;;3459:115;2990:591;;;;;;;:::o;3587:407::-;;;3712:2;3700:9;3691:7;3687:23;3683:32;3680:2;;;3728:1;3725;3718:12;3680:2;3771:1;3796:53;3841:7;3832:6;3821:9;3817:22;3796:53;:::i;:::-;3786:63;;3742:117;3898:2;3924:53;3969:7;3960:6;3949:9;3945:22;3924:53;:::i;:::-;3914:63;;3869:118;3670:324;;;;;:::o;4000:690::-;;;;;4155:3;4143:9;4134:7;4130:23;4126:33;4123:2;;;4172:1;4169;4162:12;4123:2;4215:1;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4186:117;4342:2;4368:53;4413:7;4404:6;4393:9;4389:22;4368:53;:::i;:::-;4358:63;;4313:118;4470:2;4496:52;4540:7;4531:6;4520:9;4516:22;4496:52;:::i;:::-;4486:62;;4441:117;4597:2;4623:50;4665:7;4656:6;4645:9;4641:22;4623:50;:::i;:::-;4613:60;;4568:115;4113:577;;;;;;;:::o;4696:118::-;4783:24;4801:5;4783:24;:::i;:::-;4778:3;4771:37;4761:53;;:::o;4820:109::-;4901:21;4916:5;4901:21;:::i;:::-;4896:3;4889:34;4879:50;;:::o;4935:373::-;;5067:38;5099:5;5067:38;:::i;:::-;5121:88;5202:6;5197:3;5121:88;:::i;:::-;5114:95;;5218:52;5263:6;5258:3;5251:4;5244:5;5240:16;5218:52;:::i;:::-;5295:6;5290:3;5286:16;5279:23;;5043:265;;;;;:::o;5314:159::-;5415:51;5460:5;5415:51;:::i;:::-;5410:3;5403:64;5393:80;;:::o;5479:167::-;5584:55;5633:5;5584:55;:::i;:::-;5579:3;5572:68;5562:84;;:::o;5652:364::-;;5768:39;5801:5;5768:39;:::i;:::-;5823:71;5887:6;5882:3;5823:71;:::i;:::-;5816:78;;5903:52;5948:6;5943:3;5936:4;5929:5;5925:16;5903:52;:::i;:::-;5980:29;6002:6;5980:29;:::i;:::-;5975:3;5971:39;5964:46;;5744:272;;;;;:::o;6022:369::-;;6185:67;6249:2;6244:3;6185:67;:::i;:::-;6178:74;;6282:34;6278:1;6273:3;6269:11;6262:55;6348:7;6343:2;6338:3;6334:12;6327:29;6382:2;6377:3;6373:12;6366:19;;6168:223;;;:::o;6397:370::-;;6560:67;6624:2;6619:3;6560:67;:::i;:::-;6553:74;;6657:34;6653:1;6648:3;6644:11;6637:55;6723:8;6718:2;6713:3;6709:12;6702:30;6758:2;6753:3;6749:12;6742:19;;6543:224;;;:::o;6773:370::-;;6936:67;7000:2;6995:3;6936:67;:::i;:::-;6929:74;;7033:34;7029:1;7024:3;7020:11;7013:55;7099:8;7094:2;7089:3;7085:12;7078:30;7134:2;7129:3;7125:12;7118:19;;6919:224;;;:::o;7149:306::-;;7312:66;7376:1;7371:3;7312:66;:::i;:::-;7305:73;;7408:11;7404:1;7399:3;7395:11;7388:32;7446:2;7441:3;7437:12;7430:19;;7295:160;;;:::o;7461:365::-;;7624:67;7688:2;7683:3;7624:67;:::i;:::-;7617:74;;7721:34;7717:1;7712:3;7708:11;7701:55;7787:3;7782:2;7777:3;7773:12;7766:25;7817:2;7812:3;7808:12;7801:19;;7607:219;;;:::o;7832:369::-;;7995:67;8059:2;8054:3;7995:67;:::i;:::-;7988:74;;8092:34;8088:1;8083:3;8079:11;8072:55;8158:7;8153:2;8148:3;8144:12;8137:29;8192:2;8187:3;8183:12;8176:19;;7978:223;;;:::o;8207:330::-;;8370:67;8434:2;8429:3;8370:67;:::i;:::-;8363:74;;8467:34;8463:1;8458:3;8454:11;8447:55;8528:2;8523:3;8519:12;8512:19;;8353:184;;;:::o;8543:327::-;;8706:67;8770:2;8765:3;8706:67;:::i;:::-;8699:74;;8803:31;8799:1;8794:3;8790:11;8783:52;8861:2;8856:3;8852:12;8845:19;;8689:181;;;:::o;8876:316::-;;9039:67;9103:2;9098:3;9039:67;:::i;:::-;9032:74;;9136:20;9132:1;9127:3;9123:11;9116:41;9183:2;9178:3;9174:12;9167:19;;9022:170;;;:::o;9198:323::-;;9361:67;9425:2;9420:3;9361:67;:::i;:::-;9354:74;;9458:27;9454:1;9449:3;9445:11;9438:48;9512:2;9507:3;9503:12;9496:19;;9344:177;;;:::o;9527:322::-;;9690:67;9754:2;9749:3;9690:67;:::i;:::-;9683:74;;9787:26;9783:1;9778:3;9774:11;9767:47;9840:2;9835:3;9831:12;9824:19;;9673:176;;;:::o;9855:374::-;;10018:67;10082:2;10077:3;10018:67;:::i;:::-;10011:74;;10115:34;10111:1;10106:3;10102:11;10095:55;10181:12;10176:2;10171:3;10167:12;10160:34;10220:2;10215:3;10211:12;10204:19;;10001:228;;;:::o;10235:329::-;;10398:67;10462:2;10457:3;10398:67;:::i;:::-;10391:74;;10495:33;10491:1;10486:3;10482:11;10475:54;10555:2;10550:3;10546:12;10539:19;;10381:183;;;:::o;10570:115::-;10655:23;10672:5;10655:23;:::i;:::-;10650:3;10643:36;10633:52;;:::o;10691:118::-;10778:24;10796:5;10778:24;:::i;:::-;10773:3;10766:37;10756:53;;:::o;10815:271::-;;10967:93;11056:3;11047:6;10967:93;:::i;:::-;10960:100;;11077:3;11070:10;;10949:137;;;;:::o;11092:222::-;;11223:2;11212:9;11208:18;11200:26;;11236:71;11304:1;11293:9;11289:17;11280:6;11236:71;:::i;:::-;11190:124;;;;:::o;11320:442::-;;11507:2;11496:9;11492:18;11484:26;;11520:71;11588:1;11577:9;11573:17;11564:6;11520:71;:::i;:::-;11601:72;11669:2;11658:9;11654:18;11645:6;11601:72;:::i;:::-;11683;11751:2;11740:9;11736:18;11727:6;11683:72;:::i;:::-;11474:288;;;;;;:::o;11768:332::-;;11927:2;11916:9;11912:18;11904:26;;11940:71;12008:1;11997:9;11993:17;11984:6;11940:71;:::i;:::-;12021:72;12089:2;12078:9;12074:18;12065:6;12021:72;:::i;:::-;11894:206;;;;;:::o;12106:210::-;;12231:2;12220:9;12216:18;12208:26;;12244:65;12306:1;12295:9;12291:17;12282:6;12244:65;:::i;:::-;12198:118;;;;:::o;12322:688::-;;12577:3;12566:9;12562:19;12554:27;;12591:85;12673:1;12662:9;12658:17;12649:6;12591:85;:::i;:::-;12686:72;12754:2;12743:9;12739:18;12730:6;12686:72;:::i;:::-;12768;12836:2;12825:9;12821:18;12812:6;12768:72;:::i;:::-;12850;12918:2;12907:9;12903:18;12894:6;12850:72;:::i;:::-;12932:71;12998:3;12987:9;12983:19;12974:6;12932:71;:::i;:::-;12544:466;;;;;;;;:::o;13016:258::-;;13165:2;13154:9;13150:18;13142:26;;13178:89;13264:1;13253:9;13249:17;13240:6;13178:89;:::i;:::-;13132:142;;;;:::o;13280:313::-;;13431:2;13420:9;13416:18;13408:26;;13480:9;13474:4;13470:20;13466:1;13455:9;13451:17;13444:47;13508:78;13581:4;13572:6;13508:78;:::i;:::-;13500:86;;13398:195;;;;:::o;13599:419::-;;13803:2;13792:9;13788:18;13780:26;;13852:9;13846:4;13842:20;13838:1;13827:9;13823:17;13816:47;13880:131;14006:4;13880:131;:::i;:::-;13872:139;;13770:248;;;:::o;14024:419::-;;14228:2;14217:9;14213:18;14205:26;;14277:9;14271:4;14267:20;14263:1;14252:9;14248:17;14241:47;14305:131;14431:4;14305:131;:::i;:::-;14297:139;;14195:248;;;:::o;14449:419::-;;14653:2;14642:9;14638:18;14630:26;;14702:9;14696:4;14692:20;14688:1;14677:9;14673:17;14666:47;14730:131;14856:4;14730:131;:::i;:::-;14722:139;;14620:248;;;:::o;14874:419::-;;15078:2;15067:9;15063:18;15055:26;;15127:9;15121:4;15117:20;15113:1;15102:9;15098:17;15091:47;15155:131;15281:4;15155:131;:::i;:::-;15147:139;;15045:248;;;:::o;15299:419::-;;15503:2;15492:9;15488:18;15480:26;;15552:9;15546:4;15542:20;15538:1;15527:9;15523:17;15516:47;15580:131;15706:4;15580:131;:::i;:::-;15572:139;;15470:248;;;:::o;15724:419::-;;15928:2;15917:9;15913:18;15905:26;;15977:9;15971:4;15967:20;15963:1;15952:9;15948:17;15941:47;16005:131;16131:4;16005:131;:::i;:::-;15997:139;;15895:248;;;:::o;16149:419::-;;16353:2;16342:9;16338:18;16330:26;;16402:9;16396:4;16392:20;16388:1;16377:9;16373:17;16366:47;16430:131;16556:4;16430:131;:::i;:::-;16422:139;;16320:248;;;:::o;16574:419::-;;16778:2;16767:9;16763:18;16755:26;;16827:9;16821:4;16817:20;16813:1;16802:9;16798:17;16791:47;16855:131;16981:4;16855:131;:::i;:::-;16847:139;;16745:248;;;:::o;16999:419::-;;17203:2;17192:9;17188:18;17180:26;;17252:9;17246:4;17242:20;17238:1;17227:9;17223:17;17216:47;17280:131;17406:4;17280:131;:::i;:::-;17272:139;;17170:248;;;:::o;17424:419::-;;17628:2;17617:9;17613:18;17605:26;;17677:9;17671:4;17667:20;17663:1;17652:9;17648:17;17641:47;17705:131;17831:4;17705:131;:::i;:::-;17697:139;;17595:248;;;:::o;17849:419::-;;18053:2;18042:9;18038:18;18030:26;;18102:9;18096:4;18092:20;18088:1;18077:9;18073:17;18066:47;18130:131;18256:4;18130:131;:::i;:::-;18122:139;;18020:248;;;:::o;18274:419::-;;18478:2;18467:9;18463:18;18455:26;;18527:9;18521:4;18517:20;18513:1;18502:9;18498:17;18491:47;18555:131;18681:4;18555:131;:::i;:::-;18547:139;;18445:248;;;:::o;18699:419::-;;18903:2;18892:9;18888:18;18880:26;;18952:9;18946:4;18942:20;18938:1;18927:9;18923:17;18916:47;18980:131;19106:4;18980:131;:::i;:::-;18972:139;;18870:248;;;:::o;19124:222::-;;19255:2;19244:9;19240:18;19232:26;;19268:71;19336:1;19325:9;19321:17;19312:6;19268:71;:::i;:::-;19222:124;;;;:::o;19352:332::-;;19511:2;19500:9;19496:18;19488:26;;19524:71;19592:1;19581:9;19577:17;19568:6;19524:71;:::i;:::-;19605:72;19673:2;19662:9;19658:18;19649:6;19605:72;:::i;:::-;19478:206;;;;;:::o;19690:98::-;;19775:5;19769:12;19759:22;;19748:40;;;:::o;19794:99::-;;19880:5;19874:12;19864:22;;19853:40;;;:::o;19899:147::-;;20037:3;20022:18;;20012:34;;;;:::o;20052:169::-;;20170:6;20165:3;20158:19;20210:4;20205:3;20201:14;20186:29;;20148:73;;;;:::o;20227:305::-;;20286:20;20304:1;20286:20;:::i;:::-;20281:25;;20320:20;20338:1;20320:20;:::i;:::-;20315:25;;20474:1;20406:66;20402:74;20399:1;20396:81;20393:2;;;20480:18;;:::i;:::-;20393:2;20524:1;20521;20517:9;20510:16;;20271:261;;;;:::o;20538:185::-;;20595:20;20613:1;20595:20;:::i;:::-;20590:25;;20629:20;20647:1;20629:20;:::i;:::-;20624:25;;20668:1;20658:2;;20673:18;;:::i;:::-;20658:2;20715:1;20712;20708:9;20703:14;;20580:143;;;;:::o;20729:348::-;;20792:20;20810:1;20792:20;:::i;:::-;20787:25;;20826:20;20844:1;20826:20;:::i;:::-;20821:25;;21014:1;20946:66;20942:74;20939:1;20936:81;20931:1;20924:9;20917:17;20913:105;20910:2;;;21021:18;;:::i;:::-;20910:2;21069:1;21066;21062:9;21051:20;;20777:300;;;;:::o;21083:191::-;;21143:20;21161:1;21143:20;:::i;:::-;21138:25;;21177:20;21195:1;21177:20;:::i;:::-;21172:25;;21216:1;21213;21210:8;21207:2;;;21221:18;;:::i;:::-;21207:2;21266:1;21263;21259:9;21251:17;;21128:146;;;;:::o;21280:96::-;;21346:24;21364:5;21346:24;:::i;:::-;21335:35;;21325:51;;;:::o;21382:90::-;;21459:5;21452:13;21445:21;21434:32;;21424:48;;;:::o;21478:110::-;;21558:24;21576:5;21558:24;:::i;:::-;21547:35;;21537:51;;;:::o;21594:89::-;;21670:6;21663:5;21659:18;21648:29;;21638:45;;;:::o;21689:126::-;;21766:42;21759:5;21755:54;21744:65;;21734:81;;;:::o;21821:77::-;;21887:5;21876:16;;21866:32;;;:::o;21904:154::-;;22001:51;22046:5;22001:51;:::i;:::-;21988:64;;21978:80;;;:::o;22064:127::-;;22161:24;22179:5;22161:24;:::i;:::-;22148:37;;22138:53;;;:::o;22197:162::-;;22298:55;22347:5;22298:55;:::i;:::-;22285:68;;22275:84;;;:::o;22365:131::-;;22466:24;22484:5;22466:24;:::i;:::-;22453:37;;22443:53;;;:::o;22502:307::-;22570:1;22580:113;22594:6;22591:1;22588:13;22580:113;;;22679:1;22674:3;22670:11;22664:18;22660:1;22655:3;22651:11;22644:39;22616:2;22613:1;22609:10;22604:15;;22580:113;;;22711:6;22708:1;22705:13;22702:2;;;22791:1;22782:6;22777:3;22773:16;22766:27;22702:2;22551:258;;;;:::o;22815:233::-;;22877:24;22895:5;22877:24;:::i;:::-;22868:33;;22923:66;22916:5;22913:77;22910:2;;;22993:18;;:::i;:::-;22910:2;23040:1;23033:5;23029:13;23022:20;;22858:190;;;:::o;23054:180::-;23102:77;23099:1;23092:88;23199:4;23196:1;23189:15;23223:4;23220:1;23213:15;23240:180;23288:77;23285:1;23278:88;23385:4;23382:1;23375:15;23409:4;23406:1;23399:15;23426:102;;23518:2;23514:7;23509:2;23502:5;23498:14;23494:28;23484:38;;23474:54;;;:::o;23534:122::-;23607:24;23625:5;23607:24;:::i;:::-;23600:5;23597:35;23587:2;;23646:1;23643;23636:12;23587:2;23577:79;:::o;23662:116::-;23732:21;23747:5;23732:21;:::i;:::-;23725:5;23722:32;23712:2;;23768:1;23765;23758:12;23712:2;23702:76;:::o;23784:150::-;23871:38;23903:5;23871:38;:::i;:::-;23864:5;23861:49;23851:2;;23924:1;23921;23914:12;23851:2;23841:93;:::o;23940:120::-;24012:23;24029:5;24012:23;:::i;:::-;24005:5;24002:34;23992:2;;24050:1;24047;24040:12;23992:2;23982:78;:::o;24066:122::-;24139:24;24157:5;24139:24;:::i;:::-;24132:5;24129:35;24119:2;;24178:1;24175;24168:12;24119:2;24109:79;:::o
Swarm Source
ipfs://8eba2326ab52d2d3b6f1b9f9eb74a471834c9629b6bef401d74247134272cfea
Loading...
Loading
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.