Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '../../Governable.sol';
import '../../Manageable.sol';
import '../../CollectableDust.sol';

import './HegicPoolV3Depositable.sol';
import './HegicPoolV3LotManager.sol';
import './HegicPoolV3Metadata.sol';
import './HegicPoolV3Migratable.sol';
import './HegicPoolV3ProtocolParameters.sol';
import './HegicPoolV3Withdrawable.sol';

contract HegicPoolV3 is 
  Governable,
  Manageable,
  CollectableDust,
  HegicPoolV3Metadata,
  HegicPoolV3ProtocolParameters,
  HegicPoolV3Migratable,
  HegicPoolV3Depositable,
  HegicPoolV3Withdrawable,
  HegicPoolV3LotManager {
  
  constructor(
    address[2] memory _governorAndManager,
    address _token,
    address _zToken,
    address _lotManager,
    uint256 _minTokenReserves,
    uint256 _NAVPremium,
    uint256[2] memory _NAVShares,
    address _protocolNAVPremiumRecipient
  ) public
    Governable(_governorAndManager[0])
    Manageable(_governorAndManager[1])
    CollectableDust()
    HegicPoolV3Metadata()
    HegicPoolV3ProtocolParameters(
      _token,
      _zToken,
      _lotManager,
      _minTokenReserves,
      _NAVPremium,
      _NAVShares,
      _protocolNAVPremiumRecipient)
    HegicPoolV3Migratable()
    HegicPoolV3Depositable()
    HegicPoolV3Withdrawable()
    HegicPoolV3LotManager() {
      _addProtocolToken(_token);
      _addProtocolToken(_zToken);
  }

  // Depositable
  function deposit(uint256 _amount) external override returns (uint256 _depositorShares) {
    return _deposit(_amount);
  }

  function depositAll() external override returns (uint256 _shares) {
    return _depositAll();
  }

  // Withdrawable
  function withdraw(uint256 _shares) external override returns (uint256 _underlyingToWithdraw) {
    return _withdraw(_shares);
  }

  function withdrawAll() external override returns (uint256 _underlyingToWithdraw) {
    return _withdrawAll();
  }

  // Migrable
  function migrate(address _newPool) external override onlyGovernor {
    _migrate(_newPool);
  }

  // LotManager
  function claimRewards() external override onlyManager returns (uint _rewards) {
    return _claimRewards();
  }

  function buyLots(uint256 _eth, uint256 _wbtc) external override onlyManager returns (bool) {
    return _buyLots(_eth, _wbtc);
  }

  // Protocol Parameters
  function setToken(address _token) public override onlyGovernor {
    _setToken(_token);
  }
  
  function setZToken(address _zToken) public override onlyGovernor {
    _setZToken(_zToken);
  }
  
  function setLotManager(address _lotManager) public override onlyGovernor {
    _setLotManager(_lotManager);
  }

  function setMinTokenReserves(uint256 _minTokenReserves) public override onlyGovernor {
    _setMinTokenReserves(_minTokenReserves);
  }

  function setNAVPremium(uint256 _NAVPremium) public override onlyGovernor {
    _setNAVPremium(_NAVPremium);
  }

  function setNAVPremiumShares(uint256 _poolShareOfPremium, uint256 _protocolShareOfPremium) public override onlyGovernor {
    _setNAVPremiumShares(_poolShareOfPremium, _protocolShareOfPremium);
  }

  function setProtocolNAVPremiumRecipient(address _protocolNAVPremiumRecipient) public override onlyGovernor {
    _setProtocolNAVPremiumRecipient(_protocolNAVPremiumRecipient);
  }

  // Governable
  function setPendingGovernor(address _pendingGovernor) external override onlyGovernor {
    _setPendingGovernor(_pendingGovernor);
  }

  function acceptGovernor() external override onlyPendingGovernor {
    _acceptGovernor();
  }

  // Manageable
  function setPendingManager(address _pendingManager) external override onlyManager {
    _setPendingManager(_pendingManager);
  }

  function acceptManager() external override onlyPendingManager {
    _acceptManager();
  }

  // Collectable Dust
  function sendDust(
    address _to,
    address _token,
    uint256 _amount
  ) external override onlyGovernor {
    _sendDust(_to, _token, _amount);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/EnumerableSet.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '../interfaces/ICollectableDust.sol';

abstract
contract CollectableDust is ICollectableDust {
  using EnumerableSet for EnumerableSet.AddressSet;

  address public constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
  EnumerableSet.AddressSet internal protocolTokens;

  constructor() public {}

  function _addProtocolToken(address _token) internal {
    require(!protocolTokens.contains(_token), 'collectable-dust/token-is-part-of-the-protocol');
    protocolTokens.add(_token);
  }

  function _removeProtocolToken(address _token) internal {
    require(protocolTokens.contains(_token), 'collectable-dust/token-not-part-of-the-protocol');
    protocolTokens.remove(_token);
  }

  function _sendDust(
    address _to,
    address _token,
    uint256 _amount
  ) internal {
    require(_to != address(0), 'collectable-dust/cant-send-dust-to-zero-address');
    require(!protocolTokens.contains(_token), 'collectable-dust/token-is-part-of-the-protocol');
    if (_token == ETH_ADDRESS) {
      payable(_to).transfer(_amount);
    } else {
      IERC20(_token).transfer(_to, _amount);
    }
    emit DustSent(_to, _token, _amount);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @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 in 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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface ICollectableDust {
  event DustSent(address _to, address token, uint256 amount);

  function sendDust(address _to, address _token, uint256 _amount) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '../interfaces/IGovernable.sol';

abstract
contract Governable is IGovernable {
  address public governor;
  address public pendingGovernor;

  constructor(address _governor) public {
    require(_governor != address(0), 'governable/governor-should-not-be-zero-address');
    governor = _governor;
  }

  function _setPendingGovernor(address _pendingGovernor) internal {
    require(_pendingGovernor != address(0), 'governable/pending-governor-should-not-be-zero-addres');
    pendingGovernor = _pendingGovernor;
    emit PendingGovernorSet(_pendingGovernor);
  }

  function _acceptGovernor() internal {
    governor = pendingGovernor;
    pendingGovernor = address(0);
    emit GovernorAccepted();
  }

  modifier onlyGovernor {
    require(msg.sender == governor, 'governable/only-governor');
    _;
  }

  modifier onlyPendingGovernor {
    require(msg.sender == pendingGovernor, 'governable/only-pending-governor');
    _;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '../interfaces/IManageable.sol';

abstract
contract Manageable is IManageable {
  address public manager;
  address public pendingManager;

  constructor(address _manager) public {
    require(_manager != address(0), 'manageable/manager-should-not-be-zero-address');
    manager = _manager;
  }

  function _setPendingManager(address _pendingManager) internal {
    require(_pendingManager != address(0), 'manageable/pending-manager-should-not-be-zero-addres');
    pendingManager = _pendingManager;
    emit PendingManagerSet(_pendingManager);
  }

  function _acceptManager() internal {
    manager = pendingManager;
    pendingManager = address(0);
    emit ManagerAccepted();
  }

  modifier onlyManager {
    require(msg.sender == manager, 'manageable/only-manager');
    _;
  }

  modifier onlyPendingManager {
    require(msg.sender == pendingManager, 'manageable/only-pending-manager');
    _;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';

import '../../../interfaces/HegicPool/V3/IHegicPoolV3Depositable.sol';

import './HegicPoolV3ProtocolParameters.sol';

abstract
contract HegicPoolV3Depositable is HegicPoolV3ProtocolParameters, IHegicPoolV3Depositable {

  using SafeERC20 for IERC20;
  
  function _deposit(uint256 _amount) internal returns (uint256 _depositorShares) {
    uint256 _totalUnderlying = totalUnderlying();
    uint256 _before = unusedUnderlyingBalance();
    token.safeTransferFrom(msg.sender, address(this), _amount);
    uint256 _after = unusedUnderlyingBalance();
    _amount = _after.sub(_before);
    uint256 _totalShares = zToken.totalSupply() == 0 ? _amount : (_amount.mul(zToken.totalSupply())).div(_totalUnderlying);
    uint256 _totalNAVPremium = _totalShares.mul(NAVPremium).div(NAV_PREMIUM_PRECISION).div(100);
    uint256 _protocolShares = _totalNAVPremium.mul(protocolShareOfNAVPremium).div(NAV_PREMIUM_PRECISION).div(100);
    _depositorShares = _totalShares.sub(_totalNAVPremium);
    zToken.mint(protocolNAVPremiumRecipient, _protocolShares);
    zToken.mint(msg.sender, _depositorShares);
    emit Deposited(
      msg.sender,
      _amount, 
      _depositorShares,
      _totalShares.sub(_depositorShares).sub(_protocolShares),
      _protocolShares
    );
  }

  function _depositAll() internal returns (uint256 _shares) {
    return _deposit(token.balanceOf(msg.sender));
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';

import '../../../interfaces/HegicPool/V3/IHegicPoolV3LotManager.sol';

import './HegicPoolV3ProtocolParameters.sol';

abstract
contract HegicPoolV3LotManager is HegicPoolV3ProtocolParameters, IHegicPoolV3LotManager {

  using SafeERC20 for IERC20;

  function _claimRewards() internal returns (uint _rewards) {
    _rewards = lotManager.claimRewards();
    emit RewardsClaimed(_rewards);
  }

  function _buyLots(uint256 _eth, uint256 _wbtc) internal returns (bool) {
    uint _totalLots = _eth.add(_wbtc);
    require(unusedUnderlyingBalance() >= minTokenReserves.add(_totalLots.mul(lotManager.lotPrice())), 'HegicPoolV3LotManager::_buyLots::not-enough-reserves');
    // Gets available underlying. unused - reserves
    uint256 availableUnderlying = unusedUnderlyingBalance().sub(minTokenReserves);
    // Check and approve underlyingBalace to LotManager
    token.approve(address(lotManager), availableUnderlying);
    // Calls LotManager to buyLots
    require(lotManager.buyLots(_eth, _wbtc), 'HegicPoolV3LotManager::_buyLots::error-while-buying-lots');
    emit LotsBought(_eth, _wbtc);
    return true;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '../../../interfaces/HegicPool/IHegicPoolMetadata.sol';

contract HegicPoolV3Metadata is IHegicPoolMetadata {
  function isHegicPool() external override pure returns (bool) {
    return true;
  }
  function getName() external override pure returns (string memory) {
    return 'HegicPoolV3';
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import 'hardhat/console.sol';

import '../../../interfaces/HegicPool/V3/IHegicPoolV3.sol';
import '../../../interfaces/HegicPool/V3/IHegicPoolV3Migratable.sol';
import './HegicPoolV3ProtocolParameters.sol';

abstract
contract HegicPoolV3Migratable is HegicPoolV3ProtocolParameters, IHegicPoolV3Migratable {
  function _migrate(address _newPool) internal {
    IHegicPoolV3 newPool = IHegicPoolV3(_newPool);
    require(newPool.isHegicPool(), 'HegicPoolV3Migratable::_migrate::not-setting-a-hegic-pool');
    if (address(lotManager) != address(0)) {
      lotManager.setPool(_newPool);
    }
    zToken.setPool(_newPool);
    uint poolBalance = token.balanceOf(address(this));
    token.transfer(_newPool, poolBalance);
    require(address(newPool.lotManager()) == address(lotManager), 'HegicPoolV3Migratable::_migrate::migrate-lot-manager-discrepancy');
    emit PoolMigrated(_newPool, poolBalance);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '@openzeppelin/contracts/math/SafeMath.sol';

import '../../../interfaces/HegicPool/V3/IHegicPoolV3ProtocolParameters.sol';
import '../../../interfaces/LotManager/V2/ILotManagerV2.sol';
import '../../../interfaces/IZHegic.sol';

abstract
contract HegicPoolV3ProtocolParameters is IHegicPoolV3ProtocolParameters {
  using SafeMath for uint256;

  uint256 public override constant NAV_PREMIUM_PRECISION = 10000;
  uint256 public override constant MAX_NAV_PREMIUM = 5 * NAV_PREMIUM_PRECISION / 10; // 0.5%

  uint256 public override minTokenReserves = 0;
  uint256 public override NAVPremium = 0; // 1 * NAV_PREMIUM_PRECISION / 10 = 0.1%
  uint256 public override poolShareOfNAVPremium = 90 * NAV_PREMIUM_PRECISION; // 90% of nav fee = 0.09%
  uint256 public override protocolShareOfNAVPremium = 10 * NAV_PREMIUM_PRECISION; // 10% = 0.01%
  address public override protocolNAVPremiumRecipient;

  IERC20 public override token;
  IZHegic public override zToken;
  ILotManagerV2 public override lotManager;

  constructor (
    address _token,
    address _zToken,
    address _lotManager,
    uint256 _minTokenReserves,
    uint256 _NAVPremium,
    uint256[2] memory _NAVShares,
    address _protocolNAVPremiumRecipient
  ) public {
    _setToken(_token);
    _setZToken(_zToken);
    if (_lotManager != address(0)) {
      _setLotManager(_lotManager);
    }
    _setMinTokenReserves(_minTokenReserves);
    _setNAVPremium(_NAVPremium);
    _setNAVPremiumShares(_NAVShares[0], _NAVShares[1]);
    _setProtocolNAVPremiumRecipient(_protocolNAVPremiumRecipient);
  }

  // Interfaces to addresess - For later deprecation
  function getToken() external view override returns (address) {
    return address(token);
  }

  function getZToken() external view override returns (address) {
    return address(zToken);
  }

  function getLotManager() external view override returns (address) {
    return address(lotManager);
  }

  // Calculated variables
  function unusedUnderlyingBalance() public override view returns (uint256) {
    return token.balanceOf(address(this));
  }

  function totalUnderlying() public override view returns (uint256) {
    if (address(lotManager) == address(0)) return unusedUnderlyingBalance();
    return unusedUnderlyingBalance().add(lotManager.balanceOfUnderlying());
  }

  function getPricePerFullShare() public override view returns (uint256) {
    return totalUnderlying().mul(1e18).div(zToken.totalSupply());
  }

  // Setters
  function _setMinTokenReserves(uint256 _minTokenReserves) internal {
    minTokenReserves = _minTokenReserves;
    emit MinTokenReservesSet(_minTokenReserves);
  }

  function _setNAVPremium(uint256 _NAVPremium) internal {
    require(_NAVPremium <= MAX_NAV_PREMIUM, 'HegicPoolV3::_setNAVPremium::max-nav-premium');
    NAVPremium = _NAVPremium;
    emit NAVPremiumSet(_NAVPremium);
  }

  function _setNAVPremiumShares(uint256 _poolShareOfNAVPremium, uint256 _protocolShareOfNAVPremium) internal {
    require(_poolShareOfNAVPremium.add(_protocolShareOfNAVPremium) == NAV_PREMIUM_PRECISION.mul(100), 'HegicPoolV3::_setNAVPremiumShares::shares-dont-add-up');
    poolShareOfNAVPremium = _poolShareOfNAVPremium;
    protocolShareOfNAVPremium = _protocolShareOfNAVPremium;
    emit PremiumSharesSet(_poolShareOfNAVPremium, _protocolShareOfNAVPremium);
  }

  function _setProtocolNAVPremiumRecipient(address _protocolNAVPremiumRecipient) internal {
    require(_protocolNAVPremiumRecipient != address(0), 'HegicPoolV3::_setProtocolNAVPremiumRecipient::not-zero-address');
    protocolNAVPremiumRecipient = _protocolNAVPremiumRecipient;
    emit ProtocolNAVPremiumRecipientSet(_protocolNAVPremiumRecipient);
  }

  function _setToken(address _token) internal {
    require(_token != address(0), 'HegicPoolV3::_setToken::not-zero-address');
    token = IERC20(_token);
    emit TokenSet(_token);
  }

  function _setZToken(address _zToken) internal {
    require(_zToken != address(0), 'HegicPoolV3::_setZToken::not-zero-address');
    zToken = IZHegic(_zToken);
    emit ZTokenSet(_zToken);
  }

  function _setLotManager(address _lotManager) internal {
    require(_lotManager != address(0), 'HegicPoolV3::_setLotManager::not-zero-address');
    require(ILotManagerV2(_lotManager).isLotManager(), 'HegicPoolV3::_setLotManager::not-lot-manager');
    lotManager = ILotManagerV2(_lotManager);
    emit LotManagerSet(_lotManager);
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';

import '../../../interfaces/HegicPool/V3/IHegicPoolV3Withdrawable.sol';

import './HegicPoolV3ProtocolParameters.sol';

abstract
contract HegicPoolV3Withdrawable is HegicPoolV3ProtocolParameters, IHegicPoolV3Withdrawable {

  using SafeERC20 for IERC20;

  function _withdraw(uint256 _shares) internal returns (uint256 _underlyingToWithdraw) {
    _underlyingToWithdraw = (totalUnderlying().mul(_shares)).div(zToken.totalSupply());
    zToken.burn(msg.sender, _shares);

    // Check balance
    uint256 _unusedUnderlyingBalance = unusedUnderlyingBalance();
    if (_unusedUnderlyingBalance < _underlyingToWithdraw) {
      uint256 _missingUnderlying = _underlyingToWithdraw.sub(_unusedUnderlyingBalance);

      // Check if we can close enough lots to repay withdraw
      lotManager.unwind(_missingUnderlying);

      // Revert if we still haven't got enough underlying.
      require(unusedUnderlyingBalance() >= _underlyingToWithdraw, 'HegicPoolV3Withdrawable::_withdraw::not-enough-to-unwind');
    }

    token.safeTransfer(msg.sender, _underlyingToWithdraw);
    emit Withdrew(msg.sender, _shares, _underlyingToWithdraw);
  }

  function _withdrawAll() internal returns (uint256 _underlyingToWithdraw) {
    return _withdraw(zToken.balanceOf(msg.sender));
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IGovernable {
  event PendingGovernorSet(address pendingGovernor);
  event GovernorAccepted();

  function setPendingGovernor(address _pendingGovernor) external;
  function acceptGovernor() external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IManageable {
  event PendingManagerSet(address pendingManager);
  event ManagerAccepted();

  function setPendingManager(address _pendingManager) external;
  function acceptManager() external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @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 SafeMath for uint256;
    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'
        // 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(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolV3Depositable {
  event Deposited(
    address depositor, 
    uint256 tokenAmount, 
    uint256 depositorShares,
    uint256 poolShares,
    uint256 protocolShares
  );
  function deposit(uint256 amount) external returns (uint256 shares);
  function depositAll() external returns (uint256 shares);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '../../LotManager/V2/ILotManagerV2.sol';
import '../../IZHegic.sol';

interface IHegicPoolV3ProtocolParameters {
  event MinTokenReservesSet(uint256 minTokenReserves);
  event NAVPremiumSet(uint256 NAVPremium);
  event PremiumSharesSet(uint256 _poolShareOfPremium, uint256 _protocolShareOfPremium);
  event ProtocolNAVPremiumRecipientSet(address _protocolNAVPremiumRecipient);
  event TokenSet(address _token);
  event ZTokenSet(address _zToken);
  event LotManagerSet(address _lotManager);

  // Variable getters
  function NAV_PREMIUM_PRECISION() external returns (uint256);
  function MAX_NAV_PREMIUM() external returns (uint256);

  function minTokenReserves() external returns (uint256);
  function NAVPremium() external returns (uint256);
  function poolShareOfNAVPremium() external returns (uint256);
  function protocolShareOfNAVPremium() external returns (uint256);
  function protocolNAVPremiumRecipient() external returns (address);

  function token() external returns (IERC20);
  function zToken() external returns (IZHegic);
  function lotManager() external returns (ILotManagerV2);

  // Interfaces ot addreses getters
  function getToken() external view returns (address);
  function getZToken() external view returns (address);
  function getLotManager() external view returns (address);

  // Calculated variables
  function unusedUnderlyingBalance() external view returns (uint256);
  function totalUnderlying() external view returns (uint256);
  function getPricePerFullShare() external view returns (uint256);

  // Setters
  function setMinTokenReserves(uint256 _minTokenReserves) external;
  function setNAVPremium(uint256 _NAVPremium) external;
  function setNAVPremiumShares(uint256 _poolShareOfPremium, uint256 _protocolShareOfPremium) external;
  function setProtocolNAVPremiumRecipient(address _protocolNAVPremiumRecipient) external;
  function setToken(address _token) external;
  function setZToken(address _zToken) external;
  function setLotManager(address _lotManager) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '../../IGovernable.sol';
import '../../IManageable.sol';
import '../../ICollectableDust.sol';

import '../ILotManagerMetadata.sol';

import './ILotManagerV2ProtocolParameters.sol';
import './ILotManagerV2LotsHandler.sol';
import './ILotManagerV2RewardsHandler.sol';
import './ILotManagerV2Migrable.sol';
import './ILotManagerV2Unwindable.sol';

interface ILotManagerV2 is 
  IGovernable,
  IManageable,
  ICollectableDust,
  ILotManagerMetadata, 
  ILotManagerV2ProtocolParameters, 
  ILotManagerV2LotsHandler,
  ILotManagerV2RewardsHandler,
  ILotManagerV2Migrable,
  ILotManagerV2Unwindable { }

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import './HegicPool/IHegicPoolMetadata.sol';
import './IGovernable.sol';

interface IZHegic is IERC20, IGovernable {
  function pool() external returns (IHegicPoolMetadata);
  
  function setPool(address _newPool) external;
  function mint(address account, uint256 amount) external;
  function burn(address account, uint256 amount) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface ILotManagerMetadata {
  function isLotManager() external pure returns (bool);
  function getName() external pure returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import '../../../interfaces/zTreasury/V2/IZTreasuryV2.sol';
import '../../../interfaces/HegicPool/IHegicPoolV2.sol';
import '../../../interfaces/IHegicStaking.sol';

interface ILotManagerV2ProtocolParameters {
  event PerformanceFeeSet(uint256 _performanceFee);
  event ZTreasurySet(address _zTreasury);
  event PoolSet(address _pool, address _token);
  event WETHSet(address _weth);
  event WBTCSet(address _wbtc);
  event HegicStakingSet(address _hegicStakingETH, address _hegicStakingWBTc);

  function uniswapV2() external returns (address);
  function LOT_PRICE() external returns (uint256);
  function FEE_PRECISION() external returns (uint256);
  function MAX_PERFORMANCE_FEE() external returns (uint256);
  function lotPrice() external view returns (uint256); // deprecated for LOT_PRICE
  function getPool() external view returns (address); // deprecated for pool

  function performanceFee() external returns (uint256);
  function zTreasury() external returns (IZTreasuryV2);

  function weth() external returns (address);
  function wbtc() external returns (address);
  function hegicStakingETH() external returns (IHegicStaking);
  function hegicStakingWBTC() external returns (IHegicStaking);

  function pool() external returns (IHegicPoolV2);
  function token() external returns (IERC20);

  function setPerformanceFee(uint256 _performanceFee) external;
  function setZTreasury(address _zTreasury) external;
  function setPool(address _pool) external;
  function setWETH(address _weth) external;
  function setWBTC(address _wbtc) external;
  function setHegicStaking(address _hegicStakingETH, address _hetgicStakingWBTC) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

interface ILotManagerV2LotsHandler {
  event ETHLotBought(uint256 amount);
  event WBTCLotBought(uint256 amount);
  event ETHLotSold(uint256 amount);
  event WBTCLotSold(uint256 amount);
  event LotsRebalanced(uint256 _ethLots, uint256 _wbtcLots);
  
  function balanceOfUnderlying() external view returns (uint256 _underlyingBalance);
  function balanceOfLots() external view returns (uint256 _ethLots, uint256 _wbtcLots);
  function profitOfLots() external view returns (uint256 _ethProfit, uint256 _wbtcProfit);
  function buyLots(uint256 _ethLots, uint256 _wbtcLots) external returns (bool);
  function sellLots(uint256 _ethLots, uint256 _wbtcLots) external returns (bool);
  function rebalanceLots(uint256 _ethLots, uint256 _wbtcLots) external returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

interface ILotManagerV2RewardsHandler {
  event RewardsClaimed(uint256 rewards, uint256 fees);

  function claimRewards() external returns (uint256 _totalRewards);
  function claimableRewards() external view returns (uint256 _amountOut);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

interface ILotManagerV2Migrable {
  event LotManagerMigrated(address newLotManager);

  function migrate(address newLotManager) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

interface ILotManagerV2Unwindable {
  event Unwound(uint256 amount);

  function unwind(uint256 _amount) external returns (uint256 _total);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import './IZTreasuryV2Metadata.sol';
import './IZTreasuryV2ProtocolParameters.sol';

interface IZTreasuryV2 is IZTreasuryV2ProtocolParameters, IZTreasuryV2Metadata {
  event EarningsDistributed(
    uint256 maintainerRewards, 
    uint256 governanceRewards, 
    uint256 totalEarningsDistributed
  );

  function lastEarningsDistribution() external returns (uint256);
  function totalEarningsDistributed() external returns (uint256);
  function distributeEarnings() external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '../IGovernable.sol';
import '../IManageable.sol';
import '../ICollectableDust.sol';

import './IHegicPoolMetadata.sol';
import './IHegicPoolProtocolParameters.sol';

interface IHegicPoolV2 is
  IGovernable,
  IManageable,
  ICollectableDust,
  IHegicPoolMetadata,
  IHegicPoolProtocolParameters {

  // Governance events
  event LotManagerSet(address lotManager);
  event PoolMigrated(address pool, uint256 balance);

  // Protocol events
  event RewardsClaimed(uint256 rewards);
  event LotsBought(uint256 eth, uint256 wbtc);

  // User events
  event Deposited(address depositor, uint256 tokenAmount, uint256 mintedShares);
  event Withdrew(address withdrawer, uint256 burntShares, uint256 withdrawedTokens, uint256 withdrawFee);

  function getToken() external view returns (address);
  function getZToken() external view returns (address);
  function getLotManager() external view returns (address);
  function migrate(address newPool) external;

  // User interactions
  function deposit(uint256 amount) external returns (uint256 shares);
  function depositAll() external returns (uint256 shares);
  function withdraw(uint256 shares) external returns (uint256 underlyingToWithdraw);
  function withdrawAll() external returns (uint256 underlyingToWithdraw);

  // State queries
  function unusedUnderlyingBalance() external view returns (uint256);
  function totalUnderlying() external view returns (uint256);
  function getPricePerFullShare() external view returns (uint256);

  // Lot Managment
  function setLotManager(address lotManager) external;
  function claimRewards() external returns (uint rewards);
  function buyLots(uint256 eth, uint256 wbtc) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IHegicStaking is IERC20 {    
    event Claim(address indexed acount, uint amount);
    event Profit(uint amount);

    function lockupPeriod() external view returns (uint256);
    function lastBoughtTimestamp(address) external view returns (uint256);

    function claimProfit() external returns (uint profit);
    function buy(uint amount) external;
    function sell(uint amount) external;
    function profitOf(address account) external view returns (uint);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IZTreasuryV2Metadata {
  function isZTreasury() external pure returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

interface zGovernance {
  function notifyRewardAmount(uint) external;
}

interface IZTreasuryV2ProtocolParameters {
  event ZGovSet(address zGov);
  event LotManagerSet(address lotManager);
  event MaintainerSet(address maintainer);
  event ZTokenSet(address zToken);
  event SharesSet(uint256 maintainerShare, uint256 governanceShare);

  function zToken() external returns (IERC20);

  function zGov() external returns (zGovernance);
  function lotManager() external returns (address);
  function maintainer() external returns (address);

  function SHARES_PRECISION() external returns (uint256);
  function MAX_MAINTAINER_SHARE() external returns (uint256);
  function maintainerShare() external returns (uint256);
  function governanceShare() external returns (uint256);

  function setZGov(address _zGov) external;
  function setLotManager(address _lotManager) external;
  function setMaintainer(address _maintainer) external;
  function setZToken(address _zToken) external;
  function setShares(uint256 _maintainerShare, uint256 _governanceShare) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolMetadata {
  function isHegicPool() external pure returns (bool);
  function getName() external pure returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolProtocolParameters {
  event MinTokenReservesSet(uint256 minTokenReserves);
  event WithdrawCooldownSet(uint256 withdrawCooldown);
  event WidthawFeeSet(uint256 withdrawFee);
  function setMinTokenReserves(uint256 minTokenReserves) external;
  function setWithdrawCooldown(uint256 withdrawCooldown) external;
  function setWithdrawFee(uint256 withdrawFee) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolV3LotManager {
  event RewardsClaimed(uint256 rewards);
  event LotsBought(uint256 eth, uint256 wbtc);
  function claimRewards() external returns (uint rewards);
  function buyLots(uint256 eth, uint256 wbtc) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.8.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
	}

	function logUint(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logByte(byte p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(byte)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
	}

	function log(uint p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
	}

	function log(uint p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
	}

	function log(uint p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
	}

	function log(string memory p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
	}

	function log(uint p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
	}

	function log(uint p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
	}

	function log(uint p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
	}

	function log(uint p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
	}

	function log(uint p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
	}

	function log(uint p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
	}

	function log(uint p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
	}

	function log(uint p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
	}

	function log(uint p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
	}

	function log(uint p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
	}

	function log(uint p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
	}

	function log(bool p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
	}

	function log(bool p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
	}

	function log(bool p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
	}

	function log(address p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
	}

	function log(address p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
	}

	function log(address p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '../../IGovernable.sol';
import '../../IManageable.sol';
import '../../ICollectableDust.sol';

import '../IHegicPoolMetadata.sol';

import './IHegicPoolV3ProtocolParameters.sol';
import './IHegicPoolV3LotManager.sol';
import './IHegicPoolV3Depositable.sol';
import './IHegicPoolV3Withdrawable.sol';
import './IHegicPoolV3Migratable.sol';

interface IHegicPoolV3 is 
  IGovernable,
  IManageable,
  ICollectableDust,
  IHegicPoolMetadata, 
  IHegicPoolV3ProtocolParameters, 
  IHegicPoolV3LotManager,
  IHegicPoolV3Depositable,
  IHegicPoolV3Withdrawable,
  IHegicPoolV3Migratable { }

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolV3Migratable {
  event PoolMigrated(address pool, uint256 balance);
  function migrate(address newPool) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.8;

interface IHegicPoolV3Withdrawable {
  event Withdrew(address withdrawer, uint256 burntShares, uint256 withdrawedTokens);
  function withdraw(uint256 shares) external returns (uint256 underlyingToWithdraw);
  function withdrawAll() external returns (uint256 underlyingToWithdraw);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        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);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(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
     *
     * - `to` 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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(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);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @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 { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.8;

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';

import '../interfaces/HegicPool/IHegicPoolMetadata.sol';
import './Governable.sol';

contract zHEGIC is ERC20, Governable {

  IHegicPoolMetadata public pool;

  constructor() public
    ERC20('zHEGIC', 'zHEGIC')
    Governable(msg.sender) {
  }

  modifier onlyPool {
    require(msg.sender == address(pool), 'zHEGIC/only-pool');
    _;
  }

  modifier onlyPoolOrGovernor {
    require(msg.sender == address(pool) || msg.sender == governor, 'zHEGIC/only-pool-or-governor');
    _;
  }

  function setPool(address _newPool) external onlyPoolOrGovernor {
    require(IHegicPoolMetadata(_newPool).isHegicPool(), 'zHEGIC/not-setting-a-hegic-pool');
    pool = IHegicPoolMetadata(_newPool);
  }

  function mint(address account, uint256 amount) external onlyPool {
    _mint(account, amount);
  }

  function burn(address account, uint256 amount) external onlyPool {
    _burn(account, amount);
  }

  // Governable
  function setPendingGovernor(address _pendingGovernor) external override onlyGovernor {
    _setPendingGovernor(_pendingGovernor);
  }

  function acceptGovernor() external override onlyPendingGovernor {
    _acceptGovernor();
  }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[2]","name":"_governorAndManager","type":"address[2]"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_zToken","type":"address"},{"internalType":"address","name":"_lotManager","type":"address"},{"internalType":"uint256","name":"_minTokenReserves","type":"uint256"},{"internalType":"uint256","name":"_NAVPremium","type":"uint256"},{"internalType":"uint256[2]","name":"_NAVShares","type":"uint256[2]"},{"internalType":"address","name":"_protocolNAVPremiumRecipient","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositorShares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"poolShares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"protocolShares","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DustSent","type":"event"},{"anonymous":false,"inputs":[],"name":"GovernorAccepted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_lotManager","type":"address"}],"name":"LotManagerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"eth","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"wbtc","type":"uint256"}],"name":"LotsBought","type":"event"},{"anonymous":false,"inputs":[],"name":"ManagerAccepted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minTokenReserves","type":"uint256"}],"name":"MinTokenReservesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"NAVPremium","type":"uint256"}],"name":"NAVPremiumSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingGovernor","type":"address"}],"name":"PendingGovernorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingManager","type":"address"}],"name":"PendingManagerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"}],"name":"PoolMigrated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_poolShareOfPremium","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_protocolShareOfPremium","type":"uint256"}],"name":"PremiumSharesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_protocolNAVPremiumRecipient","type":"address"}],"name":"ProtocolNAVPremiumRecipientSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewards","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_token","type":"address"}],"name":"TokenSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"withdrawer","type":"address"},{"indexed":false,"internalType":"uint256","name":"burntShares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawedTokens","type":"uint256"}],"name":"Withdrew","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_zToken","type":"address"}],"name":"ZTokenSet","type":"event"},{"inputs":[],"name":"ETH_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_NAV_PREMIUM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAVPremium","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAV_PREMIUM_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"acceptManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_eth","type":"uint256"},{"internalType":"uint256","name":"_wbtc","type":"uint256"}],"name":"buyLots","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[{"internalType":"uint256","name":"_rewards","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"_depositorShares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositAll","outputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getLotManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getPricePerFullShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getZToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isHegicPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"lotManager","outputs":[{"internalType":"contract ILotManagerV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newPool","type":"address"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minTokenReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingGovernor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolShareOfNAVPremium","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolNAVPremiumRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolShareOfNAVPremium","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"sendDust","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lotManager","type":"address"}],"name":"setLotManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minTokenReserves","type":"uint256"}],"name":"setMinTokenReserves","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_NAVPremium","type":"uint256"}],"name":"setNAVPremium","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_poolShareOfPremium","type":"uint256"},{"internalType":"uint256","name":"_protocolShareOfPremium","type":"uint256"}],"name":"setNAVPremiumShares","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingGovernor","type":"address"}],"name":"setPendingGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingManager","type":"address"}],"name":"setPendingManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_protocolNAVPremiumRecipient","type":"address"}],"name":"setProtocolNAVPremiumRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_zToken","type":"address"}],"name":"setZToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unusedUnderlyingBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"_underlyingToWithdraw","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"_underlyingToWithdraw","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"zToken","outputs":[{"internalType":"contract IZHegic","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061025e5760003560e01c806377c7b8fc11610146578063b6b55f25116100c3578063dec75e2011610087578063dec75e2014610572578063e3056a3414610595578063e58bb6391461059d578063f235757f146105a5578063f55caaee146105cb578063fc0c546a146105ee5761025e565b8063b6b55f2514610517578063c70920bc14610534578063cc2843871461053c578063ce5494bb14610544578063de5f62681461056a5761025e565b80639e1e17131161010a5780639e1e1713146104bc578063a00fff6f146104e2578063a5bda5f0146104ea578063a734f06e14610507578063ab1a877d1461050f5761025e565b806377c7b8fc14610494578063853828b61461049c5780638d170279146104a457806390239b6e146104ac5780639cac6f63146104b45761025e565b80632e1a7d4d116101df57806347bc04da116101a357806347bc04da1461042857806347d3e95b14610430578063481c6a7514610456578063482ee2e11461045e57806348ff15b31461046657806372e67d061461046e5761025e565b80632e1a7d4d146103eb5780633614c6dd14610408578063372500ab14610410578063414e57031461041857806341ce268b146104205761025e565b80631ed3ecb4116102265780631ed3ecb41461036357806321df0da71461037f578063244297eb146103875780632679497b146103ad5780632db8c129146103b55761025e565b80630b9c6d5c146102635780630c340a241461027d578063144fa6d7146102a15780631647b50a146102c957806317d7de7c146102e6575b600080fd5b61026b6105f6565b60408051918252519081900360200190f35b6102856105fc565b604080516001600160a01b039092168252519081900360200190f35b6102c7600480360360208110156102b757600080fd5b50356001600160a01b031661060b565b005b6102c7600480360360208110156102df57600080fd5b5035610664565b6102ee6106ba565b6040805160208082528351818301528351919283929083019185019080838360005b83811015610328578181015183820152602001610310565b50505050905090810190601f1680156103555780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b61036b6106e0565b604080519115158252519081900360200190f35b6102856106e5565b6102c76004803603602081101561039d57600080fd5b50356001600160a01b03166106f4565b61028561074a565b6102c7600480360360608110156103cb57600080fd5b506001600160a01b03813581169160208101359091169060400135610759565b61026b6004803603602081101561040157600080fd5b50356107b6565b61026b6107c7565b61026b6107cd565b61026b610836565b61028561083c565b61026b61084b565b6102c76004803603602081101561044657600080fd5b50356001600160a01b0316610851565b6102856108a7565b6102856108b6565b6102c76108c5565b6102c76004803603602081101561048457600080fd5b50356001600160a01b031661092e565b61026b610990565b61026b610a3b565b610285610a45565b61026b610a54565b610285610ad0565b6102c7600480360360208110156104d257600080fd5b50356001600160a01b0316610adf565b610285610b35565b6102c76004803603602081101561050057600080fd5b5035610b44565b610285610b9a565b61026b610bb2565b61026b6004803603602081101561052d57600080fd5b5035610bb8565b61026b610bc3565b61026b610c6b565b6102c76004803603602081101561055a57600080fd5b50356001600160a01b0316610c71565b61026b610cc7565b6102c76004803603604081101561058857600080fd5b5080359060200135610cd1565b610285610d2c565b6102c7610d3b565b6102c7600480360360208110156105bb57600080fd5b50356001600160a01b0316610da2565b61036b600480360360408110156105e157600080fd5b5080359060200135610df8565b610285610e65565b61138881565b6000546001600160a01b031681565b6000546001600160a01b03163314610658576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b61066181610f51565b50565b6000546001600160a01b031633146106b1576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b61066181610fea565b60408051808201909152600b81526a4865676963506f6f6c563360a81b60208201525b90565b600190565b600b546001600160a01b031690565b6000546001600160a01b03163314610741576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b61066181611066565b600d546001600160a01b031681565b6000546001600160a01b031633146107a6576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b6107b18383836110ff565b505050565b60006107c1826112ce565b92915050565b60085481565b6002546000906001600160a01b03163314610829576040805162461bcd60e51b815260206004820152601760248201527636b0b730b3b2b0b1363297b7b7363c96b6b0b730b3b2b960491b604482015290519081900360640190fd5b610831611516565b905090565b61271081565b600c546001600160a01b031690565b60065481565b6000546001600160a01b0316331461089e576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b610661816115c2565b6002546001600160a01b031681565b600d546001600160a01b031690565b6003546001600160a01b03163314610924576040805162461bcd60e51b815260206004820152601f60248201527f6d616e61676561626c652f6f6e6c792d70656e64696e672d6d616e6167657200604482015290519081900360640190fd5b61092c6116fb565b565b6002546001600160a01b03163314610987576040805162461bcd60e51b815260206004820152601760248201527636b0b730b3b2b0b1363297b7b7363c96b6b0b730b3b2b960491b604482015290519081900360640190fd5b6106618161174b565b6000610831600c60009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156109e357600080fd5b505afa1580156109f7573d6000803e3d6000fd5b505050506040513d6020811015610a0d57600080fd5b5051610a2f670de0b6b3a7640000610a23610bc3565b9063ffffffff610e7416565b9063ffffffff6117e416565b6000610831611826565b600a546001600160a01b031681565b600b54604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b158015610a9f57600080fd5b505afa158015610ab3573d6000803e3d6000fd5b505050506040513d6020811015610ac957600080fd5b5051905090565b600c546001600160a01b031681565b6000546001600160a01b03163314610b2c576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b610661816118a9565b6003546001600160a01b031681565b6000546001600160a01b03163314610b91576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b61066181611942565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee81565b60095481565b60006107c18261197d565b600d546000906001600160a01b0316610be557610bde610a54565b90506106dd565b600d5460408051634880f95160e01b81529051610831926001600160a01b031691634880f951916004808301926020929190829003018186803b158015610c2b57600080fd5b505afa158015610c3f573d6000803e3d6000fd5b505050506040513d6020811015610c5557600080fd5b5051610c5f610a54565b9063ffffffff610ecd16565b60075481565b6000546001600160a01b03163314610cbe576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b61066181611ca8565b600061083161202b565b6000546001600160a01b03163314610d1e576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b610d2882826120ae565b5050565b6001546001600160a01b031681565b6001546001600160a01b03163314610d9a576040805162461bcd60e51b815260206004820181905260248201527f676f7665726e61626c652f6f6e6c792d70656e64696e672d676f7665726e6f72604482015290519081900360640190fd5b61092c612156565b6000546001600160a01b03163314610def576040805162461bcd60e51b815260206004820152601860248201526000805160206129b8833981519152604482015290519081900360640190fd5b610661816121a6565b6002546000906001600160a01b03163314610e54576040805162461bcd60e51b815260206004820152601760248201527636b0b730b3b2b0b1363297b7b7363c96b6b0b730b3b2b960491b604482015290519081900360640190fd5b610e5e838361223f565b9392505050565b600b546001600160a01b031681565b600082610e83575060006107c1565b82820282848281610e9057fe5b0414610e5e5760405162461bcd60e51b8152600401808060200182810382526021815260200180612baf6021913960400191505060405180910390fd5b600082820183811015610e5e576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b6000610e5e836001600160a01b0384166124ce565b6000610e5e836001600160a01b0384166124e6565b6001600160a01b038116610f965760405162461bcd60e51b8152600401808060200182810382526028815260200180612a106028913960400191505060405180910390fd5b600b80546001600160a01b0383166001600160a01b0319909116811790915560408051918252517fa07c91c183e42229e705a9795a1c06d76528b673788b849597364528c96eefb79181900360200190a150565b61138881111561102b5760405162461bcd60e51b815260040180806020018281038252602c815260200180612bfc602c913960400191505060405180910390fd5b60078190556040805182815290517f5f3fb77a737ba8b588111060d57de8bc52cd5060eeff333348bc5d0984c9e8119181900360200190a150565b6001600160a01b0381166110ab5760405162461bcd60e51b815260040180806020018281038252603e815260200180612b48603e913960400191505060405180910390fd5b600a80546001600160a01b0383166001600160a01b0319909116811790915560408051918252517ffc729c6787f92ff96ac04722f5e81cdc8a1b1799ab5cb0071d9d05db32edb05d9181900360200190a150565b6001600160a01b0383166111445760405162461bcd60e51b815260040180806020018281038252602f815260200180612989602f913960400191505060405180910390fd5b61115560048363ffffffff610f2716565b156111915760405162461bcd60e51b815260040180806020018281038252602e815260200180612a6d602e913960400191505060405180910390fd5b6001600160a01b03821673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee14156111f2576040516001600160a01b0384169082156108fc029083906000818181858888f193505050501580156111ec573d6000803e3d6000fd5b5061127f565b816001600160a01b031663a9059cbb84836040518363ffffffff1660e01b815260040180836001600160a01b03166001600160a01b0316815260200182815260200192505050602060405180830381600087803b15801561125257600080fd5b505af1158015611266573d6000803e3d6000fd5b505050506040513d602081101561127c57600080fd5b50505b604080516001600160a01b0380861682528416602082015280820183905290517f1e34c1aee8e83c2dcc14c21bb4bfeea7f46c0c998cb797ac7cc4d7a18f5c656b9181900360600190a1505050565b6000611359600c60009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561132157600080fd5b505afa158015611335573d6000803e3d6000fd5b505050506040513d602081101561134b57600080fd5b5051610a2f84610a23610bc3565b600c5460408051632770a7eb60e21b81523360048201526024810186905290519293506001600160a01b0390911691639dc29fac9160448082019260009290919082900301818387803b1580156113af57600080fd5b505af11580156113c3573d6000803e3d6000fd5b5050505060006113d1610a54565b9050818110156114b35760006113ed838363ffffffff61253016565b600d5460408051637d6c4c6160e11b81526004810184905290519293506001600160a01b039091169163fad898c2916024808201926020929091908290030181600087803b15801561143e57600080fd5b505af1158015611452573d6000803e3d6000fd5b505050506040513d602081101561146857600080fd5b50839050611474610a54565b10156114b15760405162461bcd60e51b8152600401808060200182810382526038815260200180612a9b6038913960400191505060405180910390fd5b505b600b546114d0906001600160a01b0316338463ffffffff61257216565b604080513381526020810185905280820184905290517fadec52fcd1408589179b85e44b434374db078b4eaf793e7d1a1bb0ae4ecfeee59181900360600190a150919050565b600d546040805163372500ab60e01b815290516000926001600160a01b03169163372500ab91600480830192602092919082900301818787803b15801561155c57600080fd5b505af1158015611570573d6000803e3d6000fd5b505050506040513d602081101561158657600080fd5b50516040805182815290519192507fed6771ea2f01816faa7ccf034b76201581d0b4374e86f83b06a8b4191c6b9f89919081900360200190a190565b6001600160a01b0381166116075760405162461bcd60e51b815260040180806020018281038252602d81526020018061295c602d913960400191505060405180910390fd5b806001600160a01b03166337e88f526040518163ffffffff1660e01b815260040160206040518083038186803b15801561164057600080fd5b505afa158015611654573d6000803e3d6000fd5b505050506040513d602081101561166a57600080fd5b50516116a75760405162461bcd60e51b815260040180806020018281038252602c815260200180612bd0602c913960400191505060405180910390fd5b600d80546001600160a01b0383166001600160a01b0319909116811790915560408051918252517f5ea6f7e7e30b43e84fb48865238e22e6a8bb00f889f0047f73fca809d5c155c49181900360200190a150565b60038054600280546001600160a01b03199081166001600160a01b038416179091551690556040517fe612cd6de6d0c300d83e2ae8e67306e2417bed7075e47af680e1ae64c6221a5490600090a1565b6001600160a01b0381166117905760405162461bcd60e51b8152600401808060200182810382526034815260200180612cbf6034913960400191505060405180910390fd5b600380546001600160a01b0383166001600160a01b0319909116811790915560408051918252517f3025986a13cb430ec0d10d77ec0049e08699da116679264966ee1436a39562549181900360200190a150565b6000610e5e83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f0000000000008152506125c4565b600c54604080516370a0823160e01b81523360048201529051600092610831926001600160a01b03909116916370a0823191602480820192602092909190829003018186803b15801561187857600080fd5b505afa15801561188c573d6000803e3d6000fd5b505050506040513d60208110156118a257600080fd5b50516112ce565b6001600160a01b0381166118ee5760405162461bcd60e51b8152600401808060200182810382526029815260200180612b866029913960400191505060405180910390fd5b600c80546001600160a01b0383166001600160a01b0319909116811790915560408051918252517f080c862d78bce62828fa016c5bac91e4db99ae9bebcff71364ffb0bdf1627f999181900360200190a150565b60068190556040805182815290517f3ae0672ad986e3017dc127522ee23aed7fc6bd202789e513f247cfb32b0aebd29181900360200190a150565b600080611988610bc3565b90506000611994610a54565b600b549091506119b5906001600160a01b031633308763ffffffff61266616565b60006119bf610a54565b90506119d1818363ffffffff61253016565b94506000600c60009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611a2357600080fd5b505afa158015611a37573d6000803e3d6000fd5b505050506040513d6020811015611a4d57600080fd5b505115611ae757611ae284610a2f600c60009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611aa957600080fd5b505afa158015611abd573d6000803e3d6000fd5b505050506040513d6020811015611ad357600080fd5b5051899063ffffffff610e7416565b611ae9565b855b90506000611b0d6064610a2f612710610a2f60075487610e7490919063ffffffff16565b90506000611b316064610a2f612710610a2f60095487610e7490919063ffffffff16565b9050611b43838363ffffffff61253016565b600c54600a54604080516340c10f1960e01b81526001600160a01b039283166004820152602481018690529051939a509116916340c10f199160448082019260009290919082900301818387803b158015611b9d57600080fd5b505af1158015611bb1573d6000803e3d6000fd5b5050600c54604080516340c10f1960e01b8152336004820152602481018c905290516001600160a01b0390921693506340c10f19925060448082019260009290919082900301818387803b158015611c0857600080fd5b505af1158015611c1c573d6000803e3d6000fd5b505050507fe3b53cd1a44fbf11535e145d80b8ef1ed6d57a73bf5daa7e939b6b01657d6549338989611c6785611c5b8d8a61253090919063ffffffff16565b9063ffffffff61253016565b604080516001600160a01b039095168552602085019390935283830191909152606083015260808201849052519081900360a00190a1505050505050919050565b6000819050806001600160a01b0316631ed3ecb46040518163ffffffff1660e01b815260040160206040518083038186803b158015611ce657600080fd5b505afa158015611cfa573d6000803e3d6000fd5b505050506040513d6020811015611d1057600080fd5b5051611d4d5760405162461bcd60e51b8152600401808060200182810382526039815260200180612c286039913960400191505060405180910390fd5b600d546001600160a01b031615611dc557600d546040805163221b8a9560e11b81526001600160a01b03858116600483015291519190921691634437152a91602480830192600092919082900301818387803b158015611dac57600080fd5b505af1158015611dc0573d6000803e3d6000fd5b505050505b600c546040805163221b8a9560e11b81526001600160a01b03858116600483015291519190921691634437152a91602480830192600092919082900301818387803b158015611e1357600080fd5b505af1158015611e27573d6000803e3d6000fd5b5050600b54604080516370a0823160e01b81523060048201529051600094506001600160a01b0390921692506370a08231916024808301926020929190829003018186803b158015611e7857600080fd5b505afa158015611e8c573d6000803e3d6000fd5b505050506040513d6020811015611ea257600080fd5b5051600b546040805163a9059cbb60e01b81526001600160a01b03878116600483015260248201859052915193945091169163a9059cbb916044808201926020929091908290030181600087803b158015611efc57600080fd5b505af1158015611f10573d6000803e3d6000fd5b505050506040513d6020811015611f2657600080fd5b5050600d5460408051632679497b60e01b815290516001600160a01b0392831692851691632679497b9160048083019260209291908290030181600087803b158015611f7157600080fd5b505af1158015611f85573d6000803e3d6000fd5b505050506040513d6020811015611f9b57600080fd5b50516001600160a01b031614611fe25760405162461bcd60e51b8152600401808060200182810382526040815260200180612ad36040913960400191505060405180910390fd5b604080516001600160a01b03851681526020810183905281517f335ae205440a86b2cbe6e500aa3d66adcdd6f7b8db87f9045ffb2abc6581edd2929181900390910190a1505050565b600b54604080516370a0823160e01b81523360048201529051600092610831926001600160a01b03909116916370a0823191602480820192602092909190829003018186803b15801561207d57600080fd5b505afa158015612091573d6000803e3d6000fd5b505050506040513d60208110156120a757600080fd5b505161197d565b6120c1612710606463ffffffff610e7416565b6120d1838363ffffffff610ecd16565b1461210d5760405162461bcd60e51b8152600401808060200182810382526035815260200180612b136035913960400191505060405180910390fd5b60088290556009819055604080518381526020810183905281517f0e6a467276bc1b2ec017f3cd91aba404bd3e3a00f4438182ef91650733651a28929181900390910190a15050565b60018054600080546001600160a01b03199081166001600160a01b0384161782559091169091556040517f7880f0fcc848e1f26e461654b100a69f8d0641e29aa29f6596c6afadbb36b5ea9190a1565b6001600160a01b0381166121eb5760405162461bcd60e51b8152600401808060200182810382526035815260200180612a386035913960400191505060405180910390fd5b600180546001600160a01b0383166001600160a01b0319909116811790915560408051918252517f56bddfa0cee9697cebddf9acd7f23dc6583663b05e007b877056d05017994def9181900360200190a150565b600080612252848463ffffffff610ecd16565b90506122f06122e1600d60009054906101000a90046001600160a01b03166001600160a01b031663271181ec6040518163ffffffff1660e01b815260040160206040518083038186803b1580156122a857600080fd5b505afa1580156122bc573d6000803e3d6000fd5b505050506040513d60208110156122d257600080fd5b5051839063ffffffff610e7416565b6006549063ffffffff610ecd16565b6122f8610a54565b10156123355760405162461bcd60e51b8152600401808060200182810382526034815260200180612c616034913960400191505060405180910390fd5b6000612345600654611c5b610a54565b600b54600d546040805163095ea7b360e01b81526001600160a01b03928316600482015260248101859052905193945091169163095ea7b3916044808201926020929091908290030181600087803b1580156123a057600080fd5b505af11580156123b4573d6000803e3d6000fd5b505050506040513d60208110156123ca57600080fd5b5050600d5460408051637aae557760e11b8152600481018890526024810187905290516001600160a01b039092169163f55caaee916044808201926020929091908290030181600087803b15801561242157600080fd5b505af1158015612435573d6000803e3d6000fd5b505050506040513d602081101561244b57600080fd5b50516124885760405162461bcd60e51b81526004018080602001828103825260388152602001806129d86038913960400191505060405180910390fd5b604080518681526020810186905281517f20eef80dae104170efbb63ca49f0416e7aff04d5ff0744a0cf587aa200db5f19929181900390910190a1506001949350505050565b60009081526001919091016020526040902054151590565b60006124f283836124ce565b612528575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556107c1565b5060006107c1565b6000610e5e83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f7700008152506126c6565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b1790526107b1908490612720565b600081836126505760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156126155781810151838201526020016125fd565b50505050905090810190601f1680156126425780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600083858161265c57fe5b0495945050505050565b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b1790526126c0908590612720565b50505050565b600081848411156127185760405162461bcd60e51b81526020600482018181528351602484015283519092839260449091019190850190808383600083156126155781810151838201526020016125fd565b505050900390565b6060612775826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166127d19092919063ffffffff16565b8051909150156107b15780806020019051602081101561279457600080fd5b50516107b15760405162461bcd60e51b815260040180806020018281038252602a815260200180612c95602a913960400191505060405180910390fd5b60606127e084846000856127e8565b949350505050565b60606127f385612955565b612844576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b602083106128835780518252601f199092019160209182019101612864565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d80600081146128e5576040519150601f19603f3d011682016040523d82523d6000602084013e6128ea565b606091505b509150915081156128fe5791506127e09050565b80511561290e5780518082602001fd5b60405162461bcd60e51b81526020600482018181528651602484015286518793919283926044019190850190808383600083156126155781810151838201526020016125fd565b3b15159056fe4865676963506f6f6c56333a3a5f7365744c6f744d616e616765723a3a6e6f742d7a65726f2d61646472657373636f6c6c65637461626c652d647573742f63616e742d73656e642d647573742d746f2d7a65726f2d61646472657373676f7665726e61626c652f6f6e6c792d676f7665726e6f7200000000000000004865676963506f6f6c56334c6f744d616e616765723a3a5f6275794c6f74733a3a6572726f722d7768696c652d627579696e672d6c6f74734865676963506f6f6c56333a3a5f736574546f6b656e3a3a6e6f742d7a65726f2d61646472657373676f7665726e61626c652f70656e64696e672d676f7665726e6f722d73686f756c642d6e6f742d62652d7a65726f2d616464726573636f6c6c65637461626c652d647573742f746f6b656e2d69732d706172742d6f662d7468652d70726f746f636f6c4865676963506f6f6c5633576974686472617761626c653a3a5f77697468647261773a3a6e6f742d656e6f7567682d746f2d756e77696e644865676963506f6f6c56334d696772617461626c653a3a5f6d6967726174653a3a6d6967726174652d6c6f742d6d616e616765722d64697363726570616e63794865676963506f6f6c56333a3a5f7365744e41565072656d69756d5368617265733a3a7368617265732d646f6e742d6164642d75704865676963506f6f6c56333a3a5f73657450726f746f636f6c4e41565072656d69756d526563697069656e743a3a6e6f742d7a65726f2d616464726573734865676963506f6f6c56333a3a5f7365745a546f6b656e3a3a6e6f742d7a65726f2d61646472657373536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774865676963506f6f6c56333a3a5f7365744c6f744d616e616765723a3a6e6f742d6c6f742d6d616e616765724865676963506f6f6c56333a3a5f7365744e41565072656d69756d3a3a6d61782d6e61762d7072656d69756d4865676963506f6f6c56334d696772617461626c653a3a5f6d6967726174653a3a6e6f742d73657474696e672d612d68656769632d706f6f6c4865676963506f6f6c56334c6f744d616e616765723a3a5f6275794c6f74733a3a6e6f742d656e6f7567682d72657365727665735361666545524332303a204552433230206f7065726174696f6e20646964206e6f7420737563636565646d616e61676561626c652f70656e64696e672d6d616e616765722d73686f756c642d6e6f742d62652d7a65726f2d616464726573a264697066735822122047247699f7f2608d28d4f8f1ad4c4b68cd5c6449afac4d4c9d67102e2f62c08964736f6c63430006080033

000000000000000000000000752fbdcbb0242bdef2d0d6825623679c47eb7b4f0000000000000000000000005dde926b0a31346f2485900c5e64c2577f43f774000000000000000000000000584bc13c7d411c00c01a62e8019472de68768430000000000000000000000000837010619aeb2ae24141605afc8f66577f6fb2e7000000000000000000000000e8478b603380e0094bbd307d62129b004a559476000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003e800000000000000000000000000000000000000000000000000000000000dbba000000000000000000000000000000000000000000000000000000000000186a00000000000000000000000004c45fc89e3ac5a4eef16db96186150951e74dde6

-----Decoded View---------------
Arg [0] : _governorAndManager (address[2]): 0x752fbDCBB0242bdeF2D0D6825623679C47eb7B4F,0x5DDe926b0A31346f2485900C5e64c2577F43F774
Arg [1] : _token (address): 0x584bC13c7D411c00c01A62e8019472dE68768430
Arg [2] : _zToken (address): 0x837010619aeb2AE24141605aFC8f66577f6fb2e7
Arg [3] : _lotManager (address): 0xe8478b603380E0094Bbd307D62129B004A559476
Arg [4] : _minTokenReserves (uint256): 0
Arg [5] : _NAVPremium (uint256): 1000
Arg [6] : _NAVShares (uint256[2]): 900000,100000
Arg [7] : _protocolNAVPremiumRecipient (address): 0x4c45FC89e3aC5a4eeF16DB96186150951e74dDe6

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 000000000000000000000000752fbdcbb0242bdef2d0d6825623679c47eb7b4f
Arg [1] : 0000000000000000000000005dde926b0a31346f2485900c5e64c2577f43f774
Arg [2] : 000000000000000000000000584bc13c7d411c00c01a62e8019472de68768430
Arg [3] : 000000000000000000000000837010619aeb2ae24141605afc8f66577f6fb2e7
Arg [4] : 000000000000000000000000e8478b603380e0094bbd307d62129b004a559476
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [6] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [7] : 00000000000000000000000000000000000000000000000000000000000dbba0
Arg [8] : 00000000000000000000000000000000000000000000000000000000000186a0
Arg [9] : 0000000000000000000000004c45fc89e3ac5a4eef16db96186150951e74dde6