Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IUniswapV2Pair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint va ...
•    - function transferFrom(address from, a ...
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(address owner, addres ...
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function kLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(uint amount0Out, uint a ...
•    - function skim(address to)
•    - function sync()
•    - function initialize(address, address)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• library Arrays
•    - function findUpperBound(uint256[] sto ...
• interface IERC777Recipient
•    - function tokensReceived(
• interface IERC1820Registry
•    - function setManager(address account, ...
•    - function getManager(address account)
•    - function setInterfaceImplementer(addr ...
•    - function getInterfaceImplementer(addr ...
•    - function interfaceHash(string calldat ...
•    - function updateERC165Cache(address ac ...
•    - function implementsERC165Interface(ad ...
•    - function implementsERC165InterfaceNoC ...
•  contract HoprFarm is IERC777Recipi ... *
•    - function tokensReceived(
•    - function recoverToken(address token)
•    - function claimFor(address provider)
•    - function openFarmWithPermit(uint256 a ...
•    - function openFarm(uint256 amount)
•    - function claimAndClose()
•    - function closeFarm(uint256 amount)
•    - function currentFarmPeriod()
•    - function currentFarmIncentive(uint256 ...
•    - function incentiveToBeClaimed(address ...
•    - function updateEligibleBalance(addres ...
•    - function _openFarm(uint256 amount, ad ...
•    - function _claimFor(uint256 currentPer ...
•    - function _closeFarm(uint256 currentPe ...
•    - function _incentiveToBeClaimed(uint25 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-23
*/

//          
//              &&&&
//              &&&&
//              &&&&
//              &&&&  &&&&&&&&&       &&&&&&&&&&&&          &&&&&&&&&&/   &&&&.&&&&&&&&&
//              &&&&&&&&&   &&&&&   &&&&&&     &&&&&,     &&&&&    &&&&&  &&&&&&&&   &&&&
//               &&&&&&      &&&&  &&&&#         &&&&   &&&&&       &&&&& &&&&&&     &&&&&
//               &&&&&       &&&&/ &&&&           &&&& #&&&&        &&&&  &&&&&
//               &&&&         &&&& &&&&&         &&&&  &&&&        &&&&&  &&&&&
//               %%%%        /%%%%   %%%%%%   %%%%%%   %%%%  %%%%%%%%%    %%%%%
//              %%%%%        %%%%      %%%%%%%%%%%    %%%%   %%%%%%       %%%%
//                                                    %%%%
//                                                    %%%%
//                                                    %%%%
//

// File @uniswap/v2-core/contracts/interfaces/[email protected]

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/math/[email protected]

pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library 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");
        }
    }
}


// File @openzeppelin/contracts/math/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
   /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}


// File @openzeppelin/contracts/token/ERC777/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
 *
 * Accounts can be notified of {IERC777} tokens being sent to them by having a
 * contract implement this interface (contract holders can be their own
 * implementer) and registering it on the
 * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
 *
 * See {IERC1820Registry} and {ERC1820Implementer}.
 */
interface IERC777Recipient {
    /**
     * @dev Called by an {IERC777} token contract whenever tokens are being
     * moved or created into a registered account (`to`). The type of operation
     * is conveyed by `from` being the zero address or not.
     *
     * This call occurs _after_ the token contract's state is updated, so
     * {IERC777-balanceOf}, etc., can be used to query the post-operation state.
     *
     * This function may revert to prevent the operation from being executed.
     */
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external;
}


// File @openzeppelin/contracts/introspection/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the global ERC1820 Registry, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1820[EIP]. Accounts may register
 * implementers for interfaces in this registry, as well as query support.
 *
 * Implementers may be shared by multiple accounts, and can also implement more
 * than a single interface for each account. Contracts can implement interfaces
 * for themselves, but externally-owned accounts (EOA) must delegate this to a
 * contract.
 *
 * {IERC165} interfaces can also be queried via the registry.
 *
 * For an in-depth explanation and source code analysis, see the EIP text.
 */
interface IERC1820Registry {
    /**
     * @dev Sets `newManager` as the manager for `account`. A manager of an
     * account is able to set interface implementers for it.
     *
     * By default, each account is its own manager. Passing a value of `0x0` in
     * `newManager` will reset the manager to this initial state.
     *
     * Emits a {ManagerChanged} event.
     *
     * Requirements:
     *
     * - the caller must be the current manager for `account`.
     */
    function setManager(address account, address newManager) external;

    /**
     * @dev Returns the manager for `account`.
     *
     * See {setManager}.
     */
    function getManager(address account) external view returns (address);

    /**
     * @dev Sets the `implementer` contract as ``account``'s implementer for
     * `interfaceHash`.
     *
     * `account` being the zero address is an alias for the caller's address.
     * The zero address can also be used in `implementer` to remove an old one.
     *
     * See {interfaceHash} to learn how these are created.
     *
     * Emits an {InterfaceImplementerSet} event.
     *
     * Requirements:
     *
     * - the caller must be the current manager for `account`.
     * - `interfaceHash` must not be an {IERC165} interface id (i.e. it must not
     * end in 28 zeroes).
     * - `implementer` must implement {IERC1820Implementer} and return true when
     * queried for support, unless `implementer` is the caller. See
     * {IERC1820Implementer-canImplementInterfaceForAddress}.
     */
    function setInterfaceImplementer(address account, bytes32 _interfaceHash, address implementer) external;

    /**
     * @dev Returns the implementer of `interfaceHash` for `account`. If no such
     * implementer is registered, returns the zero address.
     *
     * If `interfaceHash` is an {IERC165} interface id (i.e. it ends with 28
     * zeroes), `account` will be queried for support of it.
     *
     * `account` being the zero address is an alias for the caller's address.
     */
    function getInterfaceImplementer(address account, bytes32 _interfaceHash) external view returns (address);

    /**
     * @dev Returns the interface hash for an `interfaceName`, as defined in the
     * corresponding
     * https://eips.ethereum.org/EIPS/eip-1820#interface-name[section of the EIP].
     */
    function interfaceHash(string calldata interfaceName) external pure returns (bytes32);

    /**
     *  @notice Updates the cache with whether the contract implements an ERC165 interface or not.
     *  @param account Address of the contract for which to update the cache.
     *  @param interfaceId ERC165 interface for which to update the cache.
     */
    function updateERC165Cache(address account, bytes4 interfaceId) external;

    /**
     *  @notice Checks whether a contract implements an ERC165 interface or not.
     *  If the result is not cached a direct lookup on the contract address is performed.
     *  If the result is not cached or the cached value is out-of-date, the cache MUST be updated manually by calling
     *  {updateERC165Cache} with the contract address.
     *  @param account Address of the contract to check.
     *  @param interfaceId ERC165 interface to check.
     *  @return True if `account` implements `interfaceId`, false otherwise.
     */
    function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);

    /**
     *  @notice Checks whether a contract implements an ERC165 interface or not without using nor updating the cache.
     *  @param account Address of the contract to check.
     *  @param interfaceId ERC165 interface to check.
     *  @return True if `account` implements `interfaceId`, false otherwise.
     */
    function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);

    event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);

    event ManagerChanged(address indexed account, address indexed newManager);
}


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/HoprFarm.sol

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity 0.6.12;

/**
 * 5 million HOPR tokens are allocated as incentive for liquidity providers on uniswap.
 * This incentive will be distributed on an approx. weekly-basis over 3 months (13 weeks) 
 * Liquidity providers (LPs) can deposit their LP-tokens (UniswapV2Pair token for HOPR-DAI)
 * to this HoprFarm contract for at least 1 week (minimum deposit period) to receive rewards. 
 */
contract HoprFarm is IERC777Recipient, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using Arrays for uint256[];

    uint256 public constant TOTAL_INCENTIVE = 5000000 ether;
    uint256 public constant WEEKLY_BLOCK_NUMBER = 44800; // Taking 13.5 s/block as average block time. thus 7*24*60*60/13.5 = 44800 blocks per week. 
    uint256 public constant TOTAL_CLAIM_PERIOD = 13; // Incentives are released over a period of 13 weeks. 
    uint256 public constant WEEKLY_INCENTIVE = 384615384615384615384615; // 5000000/13 weeks There is very small amount of remainder for the last week (+5 wei)

    // setup ERC1820
    IERC1820Registry private constant ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
    bytes32 private constant TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");

    struct LiquidityProvider {
        mapping(uint256=>uint256) eligibleBalance; // Amount of liquidity tokens
        uint256 claimedUntil; // the last period where the liquidity provider has claimed tokens
        uint256 currentBalance;
    }

    // an ascending block numbers of start/end of each farming interval. 
    // E.g. the first farming interval is (distributionBlocks[0], distributionBlocks[1]].
    uint256[] public distributionBlocks;
    mapping(uint256=>uint256) public eligibleLiquidityPerPeriod;
    mapping(address=>LiquidityProvider) public liquidityProviders;
    uint256 public totalPoolBalance;
    uint256 public claimedIncentive;
    address public multisig;
    IERC20 public pool; 
    IERC20 public hopr; 

    event TokenAdded(address indexed provider, uint256 indexed period, uint256 amount);
    event TokenRemoved(address indexed provider, uint256 indexed period, uint256 amount);
    event IncentiveClaimed(address indexed provider, uint256 indexed until, uint256 amount);

    /**
     * @dev Modifier to check address is multisig
     */
    modifier onlyMultisig(address adr) {
        require(adr == multisig, "HoprFarm: Only DAO multisig");
        _;
    }

    /**
     * @dev provides the farming schedule.
     * @param _pool address Address of the HOPR-DAI uniswap pool.
     * @param _token address Address of the HOPR token.
     * @param _multisig address Address of the HOPR DAO multisig.
     */
    constructor(address _pool, address _token, address _multisig) public {
        require(IUniswapV2Pair(_pool).token0() == _token || IUniswapV2Pair(_pool).token1() == _token, "HoprFarm: wrong token address");
        pool = IERC20(_pool);
        hopr = IERC20(_token);
        multisig = _multisig;
        distributionBlocks.push(0);
        ERC1820_REGISTRY.setInterfaceImplementer(address(this), TOKENS_RECIPIENT_INTERFACE_HASH, address(this));
    }

    /**
     * @dev ERC777 hook triggered when multisig send HOPR token to this contract.
     * @param operator address operator requesting the transfer
     * @param from address token holder address
     * @param to address recipient address
     * @param amount uint256 amount of tokens to transfer
     * @param userData bytes hex string of the starting block number. e.g. "0xb66bbd" for 11955133. It should not be longer than 3 bytes
     * @param operatorData bytes extra information provided by the operator (if any)
     */
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        // solhint-disable-next-line no-unused-vars
        bytes calldata operatorData
    ) external override onlyMultisig(from) nonReentrant {
        require(msg.sender == address(hopr), "HoprFarm: Sender must be HOPR token");
        require(to == address(this), "HoprFarm: Must be sending tokens to HOPR farm");
        require(amount == TOTAL_INCENTIVE, "HoprFarm: Only accept 5 million HOPR token");
        // take block number from userData, varies from 0x000000 to 0xffffff.
        // This value is sufficient as 0xffff will be in March 2023.
        require(userData.length == 3, "HoprFarm: Start block number needs to have three bytes");
        require(distributionBlocks[0] == 0, "HoprFarm: Not initialized yet.");
        bytes32 m;
        assembly {
            // it first loads the userData at the position 228 = 4 + 32 * 7, 
            // where 4 is the method signature and 7 is the storage of userData
            // Then bit shift the right-padded bytes32 to remove all the padded zeros
            // Given the blocknumber is not longer than 3 bytes, bitwise it needs to shift
            // log2(16) * (32 - 3) * 2 = 232
            m := shr(232, calldataload(228))
        }
        // update distribution blocks
        uint256 startBlock = uint256(m);
        require(startBlock >= block.number, "HoprFarm: Start block number should be in the future");
        distributionBlocks[0] = startBlock;
        for (uint256 i = 1; i <= TOTAL_CLAIM_PERIOD; i++) {
            distributionBlocks.push(startBlock + i * WEEKLY_BLOCK_NUMBER);
        }
    }

    /**
     * @dev Multisig can recover tokens (pool tokens/hopr tokens/any other random tokens)
     * @param token Address of the token to be recovered.
     */
    function recoverToken(address token) external onlyMultisig(msg.sender) nonReentrant {
        if (token == address(hopr)) {
            hopr.safeTransfer(multisig, hopr.balanceOf(address(this)).add(claimedIncentive).sub(TOTAL_INCENTIVE));
        } else if (token == address(pool)) {
            pool.safeTransfer(multisig, pool.balanceOf(address(this)).sub(totalPoolBalance));
        } else {
            IERC20(token).safeTransfer(multisig, IERC20(token).balanceOf(address(this)));
        }
    }

    /**
     * @dev Claim incenvtives for an account. Update total claimed incentive.
     * @param provider Account of liquidity provider
     */
    function claimFor(address provider) external nonReentrant {
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        _claimFor(currentPeriod, provider);
    }

    /**
     * @dev liquidity provider deposits their Uniswap HOPR-DAI tokens to the contract
     * It updates the current balance and the eligible farming balance
     * Thanks to `permit` function of UNI token (see below, link to source code), 
     * https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol
     * LPs do not need to call `approve` seperately. `spender` is this farm contract. 
     * This function can be called by anyone with a valid signature of liquidity provider.
     * @param amount Amount of pool token to be staked into the contract. It is also the amount in the signature.
     * @param owner Address of the liquidity provider.
     * @param deadline Timestamp after which the signature is no longer valid.
     * @param v ECDSA signature.
     * @param r ECDSA signature.
     * @param s ECDSA signature.
     */
    function openFarmWithPermit(uint256 amount, address owner, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
        IUniswapV2Pair(address(pool)).permit(owner, address(this), amount, deadline, v, r, s);
        _openFarm(amount, owner);
    }

    /**
     * @dev Called by liquidty provider to deposit their Uniswap HOPR-DAI tokens to the contract
     * It updates the current balance and the eligible farming balance
     * @notice An `apprpove(<farm contract>, amount)` needs to be called prior to `openFarm`
     * @param amount Amount of pool token to be staked into the contract.
     */
    function openFarm(uint256 amount) external nonReentrant {
        _openFarm(amount, msg.sender);
    }

    /**
     * @dev Claims all the reward until current block number and close the farm.
     */
    function claimAndClose() external nonReentrant {
        // get current farm period
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        _claimFor(currentPeriod, msg.sender);
        _closeFarm(currentPeriod, msg.sender, liquidityProviders[msg.sender].currentBalance);
    }

    /**
     * @dev liquidity provider removes their Uniswap HOPR-DAI tokens to the contract
     * It updates the current balance and the eligible farming balance
     * @param amount Amount of pool token to be removed from the contract.
     */
    function closeFarm(uint256 amount) external nonReentrant {
        // update balance to the right phase
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        _closeFarm(currentPeriod, msg.sender, amount);
    }

    /**
     * @dev returns the first index that contains a value greater or equal to the current `block.number`
     * If all numbers are strictly below block.number, returns array length.
     * @notice get the current farm period. 0 means "not started", 1 means "1st period", ...
     * If the returned value is larger than `maxFarmPeriod`, it means farming is "closed"
     */
    function currentFarmPeriod() public view returns (uint256) {
        return distributionBlocks.findUpperBound(block.number);
    }

    /**
     * @dev calculate virtual return based on current staking. Amount of tokens one can claim in the next period.
     * @param amountToStake Amount of pool token that a liquidity provider would stake
     */
    function currentFarmIncentive(uint256 amountToStake) public view returns (uint256) {
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        if (currentPeriod >= TOTAL_CLAIM_PERIOD) {
            return 0;            
        }
        return WEEKLY_INCENTIVE.mul(amountToStake).div(eligibleLiquidityPerPeriod[currentPeriod+1].add(amountToStake));
    }

    /**
     * @dev Get the total amount of incentive to be claimed by the liquidity provider.
     * @param provider Account of liquidity provider
     */
    function incentiveToBeClaimed(address provider) public view returns (uint256) {
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        return _incentiveToBeClaimed(currentPeriod, provider);
    }

    /**
     * @dev update the liquidity token balance, of which is used for calculating the result of farming
     * It updates the balance for the following periods. For the previous period, if the balance reduces 
     * the eligible balance of the previous round reduces. If the balance increases, it only affects the
     * following rounds.
     * @param account Address of the liquidity provider
     * @param newBalance Latest balance
     * @param currentPeriod Index of the farming period at current block number.
     */
    function updateEligibleBalance(address account, uint256 newBalance, uint256 currentPeriod) internal {
        if (currentPeriod > 0) {
            uint256 balanceFromLastPeriod = liquidityProviders[account].eligibleBalance[currentPeriod - 1];
            if (balanceFromLastPeriod > newBalance) {
                liquidityProviders[account].eligibleBalance[currentPeriod - 1] = newBalance;
                eligibleLiquidityPerPeriod[currentPeriod - 1] = eligibleLiquidityPerPeriod[currentPeriod - 1].sub(balanceFromLastPeriod).add(newBalance);
            }
        }
        uint256 newEligibleLiquidityPerPeriod = eligibleLiquidityPerPeriod[currentPeriod].sub(liquidityProviders[account].eligibleBalance[currentPeriod]).add(newBalance);
        for (uint256 i = currentPeriod; i < TOTAL_CLAIM_PERIOD; i++) {
            liquidityProviders[account].eligibleBalance[i] = newBalance;
            eligibleLiquidityPerPeriod[i] = newEligibleLiquidityPerPeriod;
        }
    }

    /**
     * @dev liquidity provider deposits their Uniswap HOPR-DAI tokens to the contract
     * It updates the current balance and the eligible farming balance
     * @param amount Amount of pool token to be staked into the contract.
     * @param provider Address of the liquidity provider.
     */
    function _openFarm(uint256 amount, address provider) internal {
        // update balance to the right phase
        uint256 currentPeriod = distributionBlocks.findUpperBound(block.number);
        require(currentPeriod < TOTAL_CLAIM_PERIOD, "HoprFarm: Farming ended");
        // always add currentBalance
        uint256 newBalance = liquidityProviders[provider].currentBalance.add(amount);
        liquidityProviders[provider].currentBalance = newBalance;
        totalPoolBalance = totalPoolBalance.add(amount);      
        // update eligible balance
        updateEligibleBalance(provider, newBalance, currentPeriod);
        // transfer token
        pool.safeTransferFrom(provider, address(this), amount);
        // emit event
        emit TokenAdded(provider, currentPeriod, amount);
    }

    /**
     * @dev Claim incenvtives for an account. Update total claimed incentive.
     * @param currentPeriod Current farm period
     * @param provider Account of liquidity provider
     */
    function _claimFor(uint256 currentPeriod, address provider) internal {
        require(currentPeriod > 1, "HoprFarm: Too early to claim");
        uint256 farmed = _incentiveToBeClaimed(currentPeriod, provider);
        require(farmed > 0, "HoprFarm: Nothing to claim");
        liquidityProviders[provider].claimedUntil = currentPeriod - 1;
        claimedIncentive = claimedIncentive.add(farmed);
        // transfer farmed tokens to the provider
        hopr.safeTransfer(provider, farmed);
        emit IncentiveClaimed(provider, currentPeriod - 1, farmed);
    }

    /**
     * @dev liquidity provider removes their Uniswap HOPR-DAI tokens to the contract
     * It updates the current balance and the eligible farming balance
     * @param currentPeriod Current farm period
     * @param provider Account of liquidity provider
     * @param amount Amount of pool token to be removed from the contract.
     */
    function _closeFarm(uint256 currentPeriod, address provider, uint256 amount) internal {
        // always add currentBalance
        uint256 newBalance = liquidityProviders[provider].currentBalance.sub(amount);
        liquidityProviders[provider].currentBalance = newBalance;
        totalPoolBalance = totalPoolBalance.sub(amount);      
        // update eligible balance
        updateEligibleBalance(provider, newBalance, currentPeriod);
        // transfer token
        pool.safeTransfer(provider, amount);
        // emit event
        emit TokenRemoved(provider, currentPeriod, amount);
    }

    /**
     * @dev Private function that gets the total amount of incentive to be claimed by the liquidity provider.
     * @param currentPeriod Current farm period
     * @param provider Account of liquidity provider
     */
    function _incentiveToBeClaimed(uint256 currentPeriod, address provider) private view returns (uint256) {
        uint256 claimedPeriod = liquidityProviders[provider].claimedUntil;
        if (currentPeriod < 1 || claimedPeriod >= currentPeriod) {
            return 0;            
        }
        uint256 farmed;
        for (uint256 i = claimedPeriod; i < currentPeriod - 1; i++) {
            if (eligibleLiquidityPerPeriod[i] > 0) {
                farmed = farmed.add(WEEKLY_INCENTIVE.mul(liquidityProviders[provider].eligibleBalance[i]).div(eligibleLiquidityPerPeriod[i]));
            }
        }
        return farmed;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_pool","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_multisig","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"provider","type":"address"},{"indexed":true,"internalType":"uint256","name":"until","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncentiveClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"provider","type":"address"},{"indexed":true,"internalType":"uint256","name":"period","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"provider","type":"address"},{"indexed":true,"internalType":"uint256","name":"period","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenRemoved","type":"event"},{"inputs":[],"name":"TOTAL_CLAIM_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_INCENTIVE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WEEKLY_BLOCK_NUMBER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WEEKLY_INCENTIVE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimAndClose","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"provider","type":"address"}],"name":"claimFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimedIncentive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"closeFarm","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountToStake","type":"uint256"}],"name":"currentFarmIncentive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentFarmPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"distributionBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"eligibleLiquidityPerPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hopr","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"provider","type":"address"}],"name":"incentiveToBeClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"liquidityProviders","outputs":[{"internalType":"uint256","name":"claimedUntil","type":"uint256"},{"internalType":"uint256","name":"currentBalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multisig","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"openFarm","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"openFarmWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"recoverToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"},{"internalType":"bytes","name":"operatorData","type":"bytes"}],"name":"tokensReceived","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalPoolBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000092c2fc5f306405eab0ff0958f6d85d7f8892cf4d000000000000000000000000f5581dfefd8fb0e4aec526be659cfab1f8c781da0000000000000000000000002d8e358487feda42629274ce041f98629bf65cf3

-----Decoded View---------------
Arg [0] : _pool (address): 0x92c2fC5F306405eaB0fF0958f6D85d7F8892CF4D
Arg [1] : _token (address): 0xF5581dFeFD8Fb0e4aeC526bE659CFaB1f8c781dA
Arg [2] : _multisig (address): 0x2D8E358487FeDa42629274CE041F98629Bf65cF3

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000092c2fc5f306405eab0ff0958f6d85d7f8892cf4d
Arg [1] : 000000000000000000000000f5581dfefd8fb0e4aec526be659cfab1f8c781da
Arg [2] : 0000000000000000000000002d8e358487feda42629274ce041f98629bf65cf3

37259:15607:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40643:1760;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40643:1760:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40643:1760:0;;-1:-1:-1;40643:1760:0;-1:-1:-1;40643:1760:0;:::i;:::-;;37422:55;;;:::i;:::-;;;;;;;;;;;;;;;;38785:31;;;:::i;47319:232::-;;;;;;;;;;;;;;;;-1:-1:-1;47319:232:0;-1:-1:-1;;;;;47319:232:0;;:::i;38853:18::-;;;:::i;:::-;;;;-1:-1:-1;;;;;38853:18:0;;;;;;;;;;;;;;45754:249;;;;;;;;;;;;;;;;-1:-1:-1;45754:249:0;;:::i;38823:23::-;;;:::i;37744:67::-;;;:::i;38747:31::-;;;:::i;37635:47::-;;;:::i;46759:392::-;;;;;;;;;;;;;;;;-1:-1:-1;46759:392:0;;:::i;38613:59::-;;;;;;;;;;;;;;;;-1:-1:-1;38613:59:0;;:::i;44333:269::-;;;;;;;;;;;;;;;;-1:-1:-1;44333:269:0;;;-1:-1:-1;;;;;44333:269:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;42579:508::-;;;;;;;;;;;;;;;;-1:-1:-1;42579:508:0;-1:-1:-1;;;;;42579:508:0;;:::i;37484:51::-;;;:::i;38879:18::-;;;:::i;38571:35::-;;;;;;;;;;;;;;;;-1:-1:-1;38571:35:0;;:::i;45179:315::-;;;:::i;38679:61::-;;;;;;;;;;;;;;;;-1:-1:-1;38679:61:0;-1:-1:-1;;;;;38679:61:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;43246:193;;;;;;;;;;;;;;;;-1:-1:-1;43246:193:0;-1:-1:-1;;;;;43246:193:0;;:::i;46398:132::-;;;:::i;44967:104::-;;;;;;;;;;;;;;;;-1:-1:-1;44967:104:0;;:::i;40643:1760::-;39313:8;;40926:4;;-1:-1:-1;;;;;39306:15:0;;;39313:8;;39306:15;39298:55;;;;;-1:-1:-1;;;39298:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1:::1;36423:7;;:19;;36415:63;;;::::0;;-1:-1:-1;;;36415:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;35817:1;36556:7;:18:::0;40986:4:::2;::::0;-1:-1:-1;;;;;40986:4:0::2;40964:10;:27;40956:75;;;;-1:-1:-1::0;;;40956:75:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;41050:19:0;::::2;41064:4;41050:19;41042:77;;;;-1:-1:-1::0;;;41042:77:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37464:13;41138:6;:25;41130:80;;;;-1:-1:-1::0;;;41130:80:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41397:1;41378:20:::0;::::2;41370:87;;;;-1:-1:-1::0;;;41370:87:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41476:18;41495:1;41476:21;;;;;;;;;;;;;;;;41501:1;41476:26;41468:69;;;::::0;;-1:-1:-1;;;41468:69:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;42004:3;41991:17;41986:3;41982:27;::::0;42133:12:::2;42119:26:::0;::::2;;42111:91;;;;-1:-1:-1::0;;;42111:91:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42237:10;42213:18;42232:1;42213:21;;;;;;;;;::::0;;;::::2;::::0;;;::::2;:34:::0;42275:1:::2;42258:138;37680:2;42278:1;:23;42258:138;;42323:18;:61:::0;;;;::::2;::::0;;-1:-1:-1;42323:61:0;;;37530:5:::2;42360:23:::0;::::2;42347:36:::0;::::2;42323:61:::0;;;::::2;::::0;42303:3:::2;42258:138;;;-1:-1:-1::0;;35773:1:0::1;36735:7;:22:::0;-1:-1:-1;;;;;;;;;;40643:1760:0:o;37422:55::-;37464:13;37422:55;:::o;38785:31::-;;;;:::o;47319:232::-;47388:7;;47432:47;:18;47466:12;47432:33;:47::i;:::-;47408:71;;47497:46;47519:13;47534:8;47497:21;:46::i;:::-;47490:53;;;47319:232;;;;:::o;38853:18::-;;;-1:-1:-1;;;;;38853:18:0;;:::o;45754:249::-;35817:1;36423:7;;:19;;36415:63;;;;;-1:-1:-1;;;36415:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1;36556:7;:18;;;45892:47:::1;:18;45926:12;45892:33;:47::i;:::-;45868:71;;45950:45;45961:13;45976:10;45988:6;45950:10;:45::i;:::-;-1:-1:-1::0;;35773:1:0;36735:7;:22;45754:249::o;38823:23::-;;;-1:-1:-1;;;;;38823:23:0;;:::o;37744:67::-;37787:24;37744:67;:::o;38747:31::-;;;;:::o;37635:47::-;37680:2;37635:47;:::o;46759:392::-;46833:7;;46877:47;:18;46911:12;46877:33;:47::i;:::-;46853:71;;37680:2;46939:13;:35;46935:88;;46998:1;46991:8;;;;;46935:88;47121:1;47107:15;;47080:43;;;;:26;:43;;;;;;47040:103;;47080:62;;47128:13;47080:47;:62::i;:::-;47040:35;37787:24;47061:13;47040:20;:35::i;:::-;:39;;:103::i;38613:59::-;;;;;;;;;;;;;:::o;44333:269::-;35817:1;36423:7;;:19;;36415:63;;;;;-1:-1:-1;;;36415:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1;36556:7;:18;;;44497:4:::1;::::0;44474:85:::1;::::0;;;;;-1:-1:-1;;;;;44474:85:0;;::::1;;::::0;::::1;::::0;44526:4:::1;44474:85:::0;;;;;;;;;;;;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;;44497:4;;;::::1;::::0;44474:36:::1;::::0;:85;;;;;;;;;;;36556:7;44497:4;44474:85;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;44570:24;44580:6;44588:5;44570:9;:24::i;:::-;-1:-1:-1::0;;35773:1:0;36735:7;:22;-1:-1:-1;;;;44333:269:0:o;42579:508::-;39313:8;;42638:10;;-1:-1:-1;;;;;39313:8:0;39306:15;;39298:55;;;;;-1:-1:-1;;;39298:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1:::1;36423:7;;:19;;36415:63;;;::::0;;-1:-1:-1;;;36415:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;35817:1;36556:7;:18:::0;42695:4:::2;::::0;-1:-1:-1;;;;;42678:22:0;;::::2;42695:4:::0;::::2;42678:22;42674:406;;;42735:8;::::0;42779:16:::2;::::0;42745:4:::2;::::0;:29:::2;::::0;;-1:-1:-1;;;42745:29:0;;42768:4:::2;42745:29;::::0;::::2;::::0;;;42717:101:::2;::::0;-1:-1:-1;;;;;42735:8:0;;::::2;::::0;42745:72:::2;::::0;37464:13:::2;::::0;42745:51:::2;::::0;42779:16;;42745:4;;::::2;::::0;:14:::2;::::0;:29;;;;;::::2;::::0;;;;;;;;;:4;:29;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;42745:29:0;;:33:::2;:51::i;:::-;:55:::0;::::2;:72::i;:::-;42717:4;::::0;-1:-1:-1;;;;;42717:4:0::2;::::0;:101;:17:::2;:101::i;:::-;42674:406;;;42857:4;::::0;-1:-1:-1;;;;;42840:22:0;;::::2;42857:4:::0;::::2;42840:22;42836:244;;;42897:8;::::0;42941:16:::2;::::0;;42907:4:::2;::::0;:29:::2;::::0;;-1:-1:-1;;;42907:29:0;;42930:4:::2;42907:29:::0;;::::2;::::0;;;;;42879:80:::2;::::0;-1:-1:-1;;;;;42897:8:0;;::::2;::::0;42907:51:::2;::::0;42941:16;42907:4;;::::2;::::0;:14:::2;::::0;:29;;;;;::::2;::::0;;;;;;;;;:4;:29;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;42907:29:0;;:33:::2;:51::i;:::-;42879:4;::::0;-1:-1:-1;;;;;42879:4:0::2;::::0;:80;:17:::2;:80::i;42836:244::-;43019:8;::::0;43029:38:::2;::::0;;-1:-1:-1;;;43029:38:0;;43061:4:::2;43029:38;::::0;::::2;::::0;;;42992:76:::2;::::0;-1:-1:-1;;;;;43019:8:0;;::::2;::::0;43029:23;;::::2;::::0;::::2;::::0;:38;;;;;::::2;::::0;;;;;;;;;:23;:38;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;43029:38:0;-1:-1:-1;;;;;42992:26:0;::::2;::::0;:76;:26:::2;:76::i;37484:51::-:0;37530:5;37484:51;:::o;38879:18::-;;;-1:-1:-1;;;;;38879:18:0;;:::o;38571:35::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38571:35:0;:::o;45179:315::-;35817:1;36423:7;;:19;;36415:63;;;;;-1:-1:-1;;;36415:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1;36556:7;:18;;;45297:47:::1;:18;45331:12;45297:33;:47::i;:::-;45273:71;;45355:36;45365:13;45380:10;45355:9;:36::i;:::-;45428:10;45440:30;::::0;;;:18:::1;:30;::::0;;;;:45:::1;;::::0;45402:84:::1;::::0;45413:13;;45402:10:::1;:84::i;:::-;-1:-1:-1::0;35773:1:0;36735:7;:22;45179:315::o;38679:61::-;;;;;;;;;;;;;;;;;;;;;:::o;43246:193::-;35817:1;36423:7;;:19;;36415:63;;;;;-1:-1:-1;;;36415:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1;36556:7;:18;;;43339:47:::1;:18;43373:12;43339:33;:47::i;:::-;43315:71;;43397:34;43407:13;43422:8;43397:9;:34::i;46398:132::-:0;46448:7;46475:47;:18;46509:12;46475:33;:47::i;:::-;46468:54;;46398:132;:::o;44967:104::-;35817:1;36423:7;;:19;;36415:63;;;;;-1:-1:-1;;;36415:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;35817:1;36556:7;:18;45034:29:::1;45044:6:::0;45052:10:::1;45034:9;:29::i;26942:918::-:0;27055:12;;27031:7;;27051:58;;-1:-1:-1;27096:1:0;27089:8;;27051:58;27162:12;;27121:11;;27187:424;27200:4;27194:3;:10;27187:424;;;27221:11;27235:23;27248:3;27253:4;27235:12;:23::i;:::-;27221:37;;27492:7;27479:5;27485:3;27479:10;;;;;;;;;;;;;;;;:20;27475:125;;;27527:3;27520:10;;27475:125;;;27577:3;27583:1;27577:7;27571:13;;27475:125;27187:424;;;;27737:1;27731:3;:7;:36;;;;;27760:7;27742:5;27754:1;27748:3;:7;27742:14;;;;;;;;;;;;;;;;:25;27731:36;27727:126;;;-1:-1:-1;;;27791:7:0;;-1:-1:-1;27784:14:0;;27727:126;-1:-1:-1;27838:3:0;-1:-1:-1;26942:918:0;;;;;:::o;52218:645::-;-1:-1:-1;;;;;52356:28:0;;52312:7;52356:28;;;:18;:28;;;;;:41;;;;;;52412:17;;;:51;;;52450:13;52433;:30;;52412:51;52408:104;;;52487:1;52480:8;;;;;52408:104;52522:14;52564:13;52547:285;52599:1;52583:13;:17;52579:1;:21;52547:285;;;52658:1;52626:29;;;:26;:29;;;;;;:33;52622:199;;52774:29;;;;:26;:29;;;;;;;;;-1:-1:-1;;;;;52721:28:0;;;;:18;:28;;;;;:47;;;;;;;;;;52689:116;;52700:104;;:69;;37787:24;;52700:20;:69::i;:104::-;52689:6;;:10;:116::i;:::-;52680:125;;52622:199;52602:3;;52547:285;;;-1:-1:-1;52849:6:0;52218:645;-1:-1:-1;;;;52218:645:0:o;51366:612::-;-1:-1:-1;;;;;51522:28:0;;51501:18;51522:28;;;:18;:28;;;;;:43;;;:55;;51570:6;51522:47;:55::i;:::-;-1:-1:-1;;;;;51588:28:0;;;;;;:18;:28;;;;;:43;;:56;;;51674:16;;51501:76;;-1:-1:-1;51674:28:0;;51695:6;51674:20;:28::i;:::-;51655:16;:47;51755:58;51777:8;51787:10;51799:13;51755:21;:58::i;:::-;51851:4;;:35;;-1:-1:-1;;;;;51851:4:0;51869:8;51879:6;51851:17;:35::i;:::-;51925:45;;;;;;;;51948:13;;-1:-1:-1;;;;;51925:45:0;;;;;;;;;;;;51366:612;;;;:::o;9031:179::-;9089:7;9121:5;;;9145:6;;;;9137:46;;;;;-1:-1:-1;;;9137:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9201:1;9031:179;-1:-1:-1;;;9031:179:0:o;9910:220::-;9968:7;9992:6;9988:20;;-1:-1:-1;10007:1:0;10000:8;;9988:20;10031:5;;;10035:1;10031;:5;:1;10055:5;;;;;:10;10047:56;;;;-1:-1:-1;;;10047:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10608:153;10666:7;10698:1;10694;:5;10686:44;;;;;-1:-1:-1;;;10686:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10752:1;10748;:5;;;;;;;10608:153;-1:-1:-1;;;10608:153:0:o;49405:814::-;49524:21;49548:47;:18;49582:12;49548:33;:47::i;:::-;49524:71;;37680:2;49614:13;:34;49606:70;;;;;-1:-1:-1;;;49606:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;49746:28:0;;49725:18;49746:28;;;:18;:28;;;;;:43;;;:55;;49794:6;49746:47;:55::i;:::-;-1:-1:-1;;;;;49812:28:0;;;;;;:18;:28;;;;;:43;;:56;;;49898:16;;49725:76;;-1:-1:-1;49898:28:0;;49919:6;49898:20;:28::i;:::-;49879:16;:47;49979:58;50001:8;50011:10;50023:13;49979:21;:58::i;:::-;50075:4;;:54;;-1:-1:-1;;;;;50075:4:0;50097:8;50115:4;50122:6;50075:21;:54::i;:::-;50168:43;;;;;;;;50189:13;;-1:-1:-1;;;;;50168:43:0;;;;;;;;;;;;49405:814;;;;:::o;9493:158::-;9551:7;9584:1;9579;:6;;9571:49;;;;;-1:-1:-1;;;9571:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9638:5:0;;;9493:158::o;22399:177::-;22509:58;;;-1:-1:-1;;;;;22509:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22532:23;22509:58;;;22482:86;;22502:5;;22482:19;:86::i;:::-;22399:177;;;:::o;50427:576::-;50531:1;50515:13;:17;50507:58;;;;;-1:-1:-1;;;50507:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;50576:14;50593:46;50615:13;50630:8;50593:21;:46::i;:::-;50576:63;;50667:1;50658:6;:10;50650:49;;;;;-1:-1:-1;;;50650:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50710:28:0;;;;;;:18;:28;;;;;-1:-1:-1;;50754:17:0;;50770:1;50710:41;;;:61;50801:16;;:28;;50822:6;50801:20;:28::i;:::-;50782:16;:47;50891:4;;:35;;-1:-1:-1;;;;;50891:4:0;50909:8;50919:6;50891:17;:35::i;:::-;50942:53;;;;;;;;-1:-1:-1;;50969:17:0;;;-1:-1:-1;;;;;50942:53:0;;;;;;;;;;;;50427:576;;;:::o;26137:193::-;26199:7;26320:1;;26311;:5;26307:1;26303;:5;:13;26302:19;;;;;;26296:1;26292;:5;26286:1;26282;:5;26281:17;:41;;26137:193;-1:-1:-1;;;26137:193:0:o;48100:986::-;48215:17;;48211:463;;-1:-1:-1;;;;;48281:27:0;;48249:29;48281:27;;;:18;:27;;;;;;;;-1:-1:-1;;48325:17:0;;48281:62;;;;;;;;48362:34;;;48358:305;;;-1:-1:-1;;;;;48417:27:0;;;;;;:18;:27;;;;;;;;-1:-1:-1;;48461:17:0;;48417:62;;;;;;;:75;;;48559:26;:45;;;;;;:88;;48482:10;;48559:72;;48609:21;48559:49;:72::i;:::-;:76;;:88::i;:::-;-1:-1:-1;;48538:17:0;;48511:45;;;;:26;:45;;;;;:136;48358:305;48211:463;;-1:-1:-1;;;;;48770:27:0;;48684:37;48770:27;;;:18;:27;;;;;;;;:58;;;;;;;;;48724:26;:41;;;;;;:121;;48834:10;;48724:105;;:45;:105::i;:121::-;48684:161;-1:-1:-1;48873:13:0;48856:223;37680:2;48888:1;:22;48856:223;;;-1:-1:-1;;;;;48932:27:0;;;;;;:18;:27;;;;;;;;:46;;;;;;;;:59;;;49006:26;:29;;;;;:61;;;48912:3;;48856:223;;;;48100:986;;;;:::o;22584:205::-;22712:68;;;-1:-1:-1;;;;;22712:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22735:27;22712:68;;;22685:96;;22705:5;;22685:19;:96::i;:::-;22584:205;;;;:::o;24704:761::-;25128:23;25154:69;25182:4;25154:69;;;;;;;;;;;;;;;;;25162:5;-1:-1:-1;;;;;25154:27:0;;;:69;;;;;:::i;:::-;25238:17;;25128:95;;-1:-1:-1;25238:21:0;25234:224;;25380:10;25369:30;;;;;;;;;;;;;;;-1:-1:-1;25369:30:0;25361:85;;;;-1:-1:-1;;;25361:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17394:195;17497:12;17529:52;17551:6;17559:4;17565:1;17568:12;17529:21;:52::i;:::-;17522:59;17394:195;-1:-1:-1;;;;17394:195:0:o;18446:530::-;18573:12;18631:5;18606:21;:30;;18598:81;;;;-1:-1:-1;;;18598:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18698:18;18709:6;18698:10;:18::i;:::-;18690:60;;;;;-1:-1:-1;;;18690:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;18824:12;18838:23;18865:6;-1:-1:-1;;;;;18865:11:0;18885:5;18893:4;18865:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;18865:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18823:75;;;;18916:52;18934:7;18943:10;18955:12;18916:17;:52::i;:::-;18909:59;18446:530;-1:-1:-1;;;;;;;18446:530:0:o;14476:422::-;14843:20;14882:8;;;14476:422::o;20986:742::-;21101:12;21130:7;21126:595;;;-1:-1:-1;21161:10:0;21154:17;;21126:595;21275:17;;:21;21271:439;;21538:10;21532:17;21599:15;21586:10;21582:2;21578:19;21571:44;21486:148;21681:12;21674:20;;-1:-1:-1;;;21674:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://8c0ada7892119cc400f3326564817aab881e9af2beb77719543b48113ea32438