Contract 0x5cee2988184afe3cd807e0178b394259e8cdc56c

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;

import "@boringcrypto/boring-solidity/contracts/libraries/BoringMath.sol";
import "@boringcrypto/boring-solidity/contracts/BoringBatchable.sol";
import "@boringcrypto/boring-solidity/contracts/BoringOwnable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "./libraries/SignedSafeMath.sol";
import "./interfaces/IRewarder.sol";
import "./interfaces/IMasterChef.sol";
import "./interfaces/ILiquidDepositor.sol";
import "./interfaces/IStrategy.sol";


/// @notice The (older) MasterChef contract gives out a constant number of LQDR tokens per block.
/// It is the only address with minting rights for LQDR.
/// The idea for this MasterChef V2 (MCV2) contract is therefore to be the owner of a dummy token
/// that is deposited into the MasterChef V1 (MCV1) contract.
/// The allocation point for this pool on MCV1 is the total allocation point for all pools that receive double incentives.
contract MasterChefV2 is OwnableUpgradeable {
    using SafeMath for uint256;
    using BoringMath128 for uint128;
    using BoringERC20 for IERC20;
    using SignedSafeMath for int256;

    /// @notice Info of each MCV2 user.
    /// `amount` LP token amount the user has provided.
    /// `rewardDebt` The amount of LQDR entitled to the user.
    struct UserInfo {
        uint256 amount;
        int256 rewardDebt;
    }

    /// @notice Info of each MCV2 pool.
    /// `allocPoint` The amount of allocation points assigned to the pool.
    /// Also known as the amount of LQDR to distribute per block.
    struct PoolInfo {
        uint256 accLqdrPerShare;
        uint256 lastRewardBlock;
        uint256 allocPoint;
        uint256 depositFee;
    }

    /// @notice Address of MCV1 contract.
    IMasterChef public MASTER_CHEF;
    /// @notice Address of LQDR contract.
    IERC20 public LQDR;
    /// @notice The index of MCV2 master pool in MCV1.
    uint256 public MASTER_PID;

    /// @notice Info of each MCV2 pool.
    PoolInfo[] public poolInfo;
    /// @notice Address of the LP token for each MCV2 pool.
    IERC20[] public lpToken;
    /// @notice Address of each `IRewarder` contract in MCV2.
    IRewarder[] public rewarder;
    /// @notice Address of each `IStrategy`.
    IStrategy[] public strategies;

    /// @notice Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    /// @dev Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint;

    uint256 public MASTERCHEF_LQDR_PER_BLOCK;
    uint256 public ACC_LQDR_PRECISION;

    // Deposit Fee Address
    address public feeAddress;

    mapping (uint256 => address) public feeAddresses;

    address public treasury;

    // LiquidDepositor address
    address public liquidDepositor;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount, address indexed to);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount, address indexed to);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount, address indexed to);
    event Harvest(address indexed user, uint256 indexed pid, uint256 amount);
    event LogPoolAddition(uint256 indexed pid, uint256 allocPoint, IERC20 indexed lpToken, IRewarder indexed rewarder);
    event LogSetPool(uint256 indexed pid, uint256 allocPoint, IRewarder indexed rewarder, bool overwrite);
    event LogUpdatePool(uint256 indexed pid, uint256 lastRewardBlock, uint256 lpSupply, uint256 accLqdrPerShare);
    event LogInit();
    event DepositToLiquidDepositor(uint256 amount, address token);
    event WithdrawFromLiquidDepositor(uint256 amount, address token);

    constructor() public {
    }

    function initialize(IERC20 _lqdr, address _feeAddress, address _treasury) public initializer {
        __Ownable_init();
        LQDR = _lqdr;
        feeAddress = _feeAddress;
        treasury = _treasury;
        ACC_LQDR_PRECISION = 1e18;
    }

    function setMasterChef(IMasterChef masterChef, uint256 masterPid, uint256 masterChefLqdrPerBlock) external onlyOwner {
        MASTER_CHEF = masterChef;
        MASTER_PID = masterPid;
        MASTERCHEF_LQDR_PER_BLOCK = masterChefLqdrPerBlock;
    }
    
    function setFeeAddress(address _feeAddress) public {
        require(msg.sender == feeAddress || msg.sender == owner(), "setFeeAddress: FORBIDDEN");
        feeAddress = _feeAddress;
    }

    function setFeeAddresses(uint256 pid, address _feeAddress) public {
        require(msg.sender == feeAddress || msg.sender == owner(), "setFeeAddress: FORBIDDEN");
        feeAddresses[pid] = _feeAddress;
    }
    
    function setTreasuryAddress(address _treasuryAddress) public {
        require(msg.sender == treasury || msg.sender == owner(), "setTreasuryAddress: FORBIDDEN");
        treasury = _treasuryAddress;
    }

    /// @notice Deposits a dummy token to `MASTER_CHEF` MCV1. This is required because MCV1 holds the minting rights for LQDR.
    /// Any balance of transaction sender in `dummyToken` is transferred.
    /// The allocation point for the pool on MCV1 is the total allocation point for all pools that receive double incentives.
    /// @param dummyToken The address of the ERC-20 token to deposit into MCV1.
    function init(IERC20 dummyToken) external {
        uint256 balance = dummyToken.balanceOf(msg.sender);
        require(balance != 0, "MasterChefV2: Balance must exceed 0");
        dummyToken.safeTransferFrom(msg.sender, address(this), balance);
        dummyToken.approve(address(MASTER_CHEF), balance);
        MASTER_CHEF.deposit(MASTER_PID, balance);
        emit LogInit();
    }

    /// @notice Returns the number of MCV2 pools.
    function poolLength() public view returns (uint256 pools) {
        pools = poolInfo.length;
    }

    /// @notice Add a new LP to the pool. Can only be called by the owner.
    /// DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    /// @param allocPoint AP of the new pool.
    /// @param _lpToken Address of the LP ERC-20 token.
    /// @param _rewarder Address of the rewarder delegate.
    function add(uint256 allocPoint, IERC20 _lpToken, IRewarder _rewarder, IStrategy _strategy, uint256 _depositFee) public onlyOwner {
        uint256 lastRewardBlock = block.number;
        totalAllocPoint = totalAllocPoint.add(allocPoint);
        lpToken.push(_lpToken);
        rewarder.push(_rewarder);
        strategies.push(_strategy);

        poolInfo.push(PoolInfo({
            allocPoint: allocPoint,
            lastRewardBlock: lastRewardBlock,
            accLqdrPerShare: 0,
            depositFee: _depositFee
        }));
        emit LogPoolAddition(lpToken.length.sub(1), allocPoint, _lpToken, _rewarder);
    }

    /// @notice Update the given pool's LQDR allocation point and `IRewarder` contract. Can only be called by the owner.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _allocPoint New AP of the pool.
    /// @param _rewarder Address of the rewarder delegate.
    /// @param overwrite True if _rewarder should be `set`. Otherwise `_rewarder` is ignored.
    function set(uint256 _pid, uint256 _allocPoint, IRewarder _rewarder, IStrategy _strategy, uint256 _depositFee, bool overwrite) public onlyOwner {
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFee = _depositFee;
        if (overwrite) { 
            rewarder[_pid] = _rewarder; 

            if (address(strategies[_pid]) != address(_strategy)) {
                if (address(strategies[_pid]) != address(0)) {
                    _withdrawAllFromStrategy(_pid, strategies[_pid]);
                }
                if (address(_strategy) != address(0)) {
                    _depositAllToStrategy(_pid, _strategy);
                }
                strategies[_pid] = _strategy; 
            }
        }

        emit LogSetPool(_pid, _allocPoint, overwrite ? _rewarder : rewarder[_pid], overwrite);
    }

    function _withdrawAllFromStrategy(uint256 _pid, IStrategy _strategy) internal {
        IERC20 _lpToken = lpToken[_pid];
        uint256 _strategyBalance = _strategy.balanceOf();
        require(address(_lpToken) == _strategy.want(), '!lpToken');

        if (_strategyBalance > 0) {
            _strategy.withdraw(_strategyBalance);
            uint256 _currentBalance = _lpToken.balanceOf(address(this));

            require(_currentBalance >= _strategyBalance, '!balance1');

            _strategyBalance = _strategy.balanceOf();
            require(_strategyBalance == 0, '!balance2');
        }
    }

    function _depositAllToStrategy(uint256 _pid, IStrategy _strategy) internal {
        IERC20 _lpToken = lpToken[_pid];
        uint256 _strategyBalanceBefore = _strategy.balanceOf();
        uint256 _balanceBefore = _lpToken.balanceOf(address(this));
        require(address(_lpToken) == _strategy.want(), '!lpToken');

        if (_balanceBefore > 0) {
            _lpToken.safeTransfer(address(_strategy), _balanceBefore);
            _strategy.deposit();

            uint256 _strategyBalanceAfter = _strategy.balanceOf();
            uint256 _strategyBalanceDiff = _strategyBalanceAfter.sub(_strategyBalanceBefore);

            require(_strategyBalanceDiff == _balanceBefore, '!balance1');

            uint256 _balanceAfter = _lpToken.balanceOf(address(this));
            require(_balanceAfter == 0, '!balance2');
        }
    }

    /// @notice View function to see pending LQDR on frontend.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _user Address of user.
    /// @return pending LQDR reward for a given user.
    function pendingLqdr(uint256 _pid, address _user) external view returns (uint256 pending) {
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accLqdrPerShare = pool.accLqdrPerShare;
        uint256 lpSupply;

        if (address(strategies[_pid]) != address(0)) {
            lpSupply = lpToken[_pid].balanceOf(address(this)).add(strategies[_pid].balanceOf());
        }
        else {
            lpSupply = lpToken[_pid].balanceOf(address(this));
        }

        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 blocks = block.number.sub(pool.lastRewardBlock);
            uint256 lqdrReward = blocks.mul(lqdrPerBlock()).mul(pool.allocPoint) / totalAllocPoint;
            accLqdrPerShare = accLqdrPerShare.add(lqdrReward.mul(ACC_LQDR_PRECISION) / lpSupply);
        }
        pending = int256(user.amount.mul(accLqdrPerShare) / ACC_LQDR_PRECISION).sub(user.rewardDebt).toUInt256();
    }

    /// @notice Update reward variables for all pools. Be careful of gas spending!
    /// @param pids Pool IDs of all to be updated. Make sure to update all active pools.
    function massUpdatePools(uint256[] calldata pids) external {
        uint256 len = pids.length;
        for (uint256 i = 0; i < len; ++i) {
            updatePool(pids[i]);
        }
    }

    function massHarvestFromStrategies() external {
        uint256 len = strategies.length;
        for (uint256 i = 0; i < len; ++i) {
            if (address(strategies[i]) != address(0)) {
                strategies[i].harvest();
            }
        }
    }

    /// @notice Calculates and returns the `amount` of LQDR per block.
    function lqdrPerBlock() public view returns (uint256 amount) {
        amount = uint256(MASTERCHEF_LQDR_PER_BLOCK)
            .mul(MASTER_CHEF.poolInfo(MASTER_PID).allocPoint) / MASTER_CHEF.totalAllocPoint();
    }

    /// @notice Update reward variables of the given pool.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @return pool Returns the pool that was updated.
    function updatePool(uint256 pid) public returns (PoolInfo memory pool) {
        pool = poolInfo[pid];
        if (block.number > pool.lastRewardBlock) {
            uint256 lpSupply;

            if (address(strategies[pid]) != address(0)) {
                lpSupply = lpToken[pid].balanceOf(address(this)).add(strategies[pid].balanceOf());
            }
            else {
                lpSupply = lpToken[pid].balanceOf(address(this));
            }
             
            if (lpSupply > 0) {
                uint256 blocks = block.number.sub(pool.lastRewardBlock);
                uint256 lqdrReward = blocks.mul(lqdrPerBlock()).mul(pool.allocPoint) / totalAllocPoint;
                pool.accLqdrPerShare = pool.accLqdrPerShare.add(lqdrReward.mul(ACC_LQDR_PRECISION) / lpSupply);
            }
            pool.lastRewardBlock = block.number;
            poolInfo[pid] = pool;
            emit LogUpdatePool(pid, pool.lastRewardBlock, lpSupply, pool.accLqdrPerShare);
        }
    }

    /// @notice Deposit LP tokens to MCV2 for LQDR allocation.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param amount LP token amount to deposit.
    /// @param to The receiver of `amount` deposit benefit.
    function deposit(uint256 pid, uint256 amount, address to) public {
        PoolInfo memory pool = updatePool(pid);
        UserInfo storage user = userInfo[pid][to];
        address _feeAddress = feeAddresses[pid];

        if (_feeAddress == address(0)) {
            _feeAddress = feeAddress;
        }

        // Effects
        uint256 depositFeeAmount = amount.mul(pool.depositFee).div(10000);
        user.amount = user.amount.add(amount).sub(depositFeeAmount);
        user.rewardDebt = user.rewardDebt.add(int256(amount.mul(pool.accLqdrPerShare) / ACC_LQDR_PRECISION));

        // Interactions
        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onLqdrReward(pid, to, to, 0, user.amount);
        }

        lpToken[pid].safeTransferFrom(msg.sender, address(this), amount);
        lpToken[pid].safeTransfer(_feeAddress, depositFeeAmount);

        IStrategy _strategy = strategies[pid];
        if (address(_strategy) != address(0)) {
            uint256 _amount = lpToken[pid].balanceOf(address(this));
            lpToken[pid].safeTransfer(address(_strategy), _amount);
            _strategy.deposit();
        }

        emit Deposit(msg.sender, pid, amount, to);
    }

    function _withdraw(uint256 amount, uint256 pid, address to) internal returns (uint256) {
        uint256 balance = lpToken[pid].balanceOf(address(this));
        IStrategy strategy = strategies[pid];
        if (amount > balance) {
            uint256 missing = amount.sub(balance);
            uint256 withdrawn = strategy.withdraw(missing);
            amount = balance.add(withdrawn);
        }

        lpToken[pid].safeTransfer(to, amount);

        return amount;
    }

    /// @notice Withdraw LP tokens from MCV2.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param amount LP token amount to withdraw.
    /// @param to Receiver of the LP tokens.
    function withdraw(uint256 pid, uint256 amount, address to) public {
        PoolInfo memory pool = updatePool(pid);
        UserInfo storage user = userInfo[pid][msg.sender];

        // Effects
        user.rewardDebt = user.rewardDebt.sub(int256(amount.mul(pool.accLqdrPerShare) / ACC_LQDR_PRECISION));
        user.amount = user.amount.sub(amount);

        // Interactions
        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onLqdrReward(pid, msg.sender, to, 0, user.amount);
        }
        
        // lpToken[pid].safeTransfer(to, amount);
        amount = _withdraw(amount, pid, to);

        emit Withdraw(msg.sender, pid, amount, to);
    }

    /// @notice Harvest proceeds for transaction sender to `to`.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param to Receiver of LQDR rewards.
    function harvest(uint256 pid, address to) public {
        PoolInfo memory pool = updatePool(pid);
        UserInfo storage user = userInfo[pid][msg.sender];
        int256 accumulatedLqdr = int256(user.amount.mul(pool.accLqdrPerShare) / ACC_LQDR_PRECISION);
        uint256 _pendingLqdr = accumulatedLqdr.sub(user.rewardDebt).toUInt256();

        harvestFromMasterChef();

        // Effects
        user.rewardDebt = accumulatedLqdr;

        // Interactions
        if (_pendingLqdr != 0) {
            LQDR.safeTransfer(to, _pendingLqdr);
        }
        
        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onLqdrReward( pid, msg.sender, to, _pendingLqdr, user.amount);
        }

        emit Harvest(msg.sender, pid, _pendingLqdr);
    }
    
    /// @notice Withdraw LP tokens from MCV2 and harvest proceeds for transaction sender to `to`.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param amount LP token amount to withdraw.
    /// @param to Receiver of the LP tokens and LQDR rewards.
    function withdrawAndHarvest(uint256 pid, uint256 amount, address to) public {
        PoolInfo memory pool = updatePool(pid);
        UserInfo storage user = userInfo[pid][msg.sender];
        int256 accumulatedLqdr = int256(user.amount.mul(pool.accLqdrPerShare) / ACC_LQDR_PRECISION);
        uint256 _pendingLqdr = accumulatedLqdr.sub(user.rewardDebt).toUInt256();

        // Effects
        user.rewardDebt = accumulatedLqdr.sub(int256(amount.mul(pool.accLqdrPerShare) / ACC_LQDR_PRECISION));
        user.amount = user.amount.sub(amount);
        
        // Interactions
        LQDR.safeTransfer(to, _pendingLqdr);

        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onLqdrReward(pid, msg.sender, to, _pendingLqdr, user.amount);
        }

        // lpToken[pid].safeTransfer(to, amount);
        _withdraw(amount, pid, to);

        emit Withdraw(msg.sender, pid, amount, to);
        emit Harvest(msg.sender, pid, _pendingLqdr);
    }

    /// @notice Harvests LQDR from `MASTER_CHEF` MCV1 and pool `MASTER_PID` to this MCV2 contract.
    function harvestFromMasterChef() public {
        MASTER_CHEF.deposit(MASTER_PID, 0);
    }

    /// @notice Withdraw without caring about rewards. EMERGENCY ONLY.
    /// @param pid The index of the pool. See `poolInfo`.
    /// @param to Receiver of the LP tokens.
    function emergencyWithdraw(uint256 pid, address to) public {
        UserInfo storage user = userInfo[pid][msg.sender];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        IRewarder _rewarder = rewarder[pid];
        if (address(_rewarder) != address(0)) {
            _rewarder.onLqdrReward(pid, msg.sender, to, 0, 0);
        }

        // Note: transfer can fail or succeed if `amount` is zero.
        amount = _withdraw(amount, pid, to);
        // lpToken[pid].safeTransfer(to, amount);
        emit EmergencyWithdraw(msg.sender, pid, amount, to);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// a library for performing overflow-safe math, updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math)
library BoringMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {require((c = a + b) >= b, "BoringMath: Add Overflow");}
    function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {require((c = a - b) <= a, "BoringMath: Underflow");}
    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {require(b == 0 || (c = a * b)/b == a, "BoringMath: Mul Overflow");}
    function to128(uint256 a) internal pure returns (uint128 c) {
        require(a <= uint128(-1), "BoringMath: uint128 Overflow");
        c = uint128(a);
    }
    function to64(uint256 a) internal pure returns (uint64 c) {
        require(a <= uint64(-1), "BoringMath: uint64 Overflow");
        c = uint64(a);
    }
    function to32(uint256 a) internal pure returns (uint32 c) {
        require(a <= uint32(-1), "BoringMath: uint32 Overflow");
        c = uint32(a);
    }
}

library BoringMath128 {
    function add(uint128 a, uint128 b) internal pure returns (uint128 c) {require((c = a + b) >= b, "BoringMath: Add Overflow");}
    function sub(uint128 a, uint128 b) internal pure returns (uint128 c) {require((c = a - b) <= a, "BoringMath: Underflow");}
}

library BoringMath64 {
    function add(uint64 a, uint64 b) internal pure returns (uint64 c) {require((c = a + b) >= b, "BoringMath: Add Overflow");}
    function sub(uint64 a, uint64 b) internal pure returns (uint64 c) {require((c = a - b) <= a, "BoringMath: Underflow");}
}

library BoringMath32 {
    function add(uint32 a, uint32 b) internal pure returns (uint32 c) {require((c = a + b) >= b, "BoringMath: Add Overflow");}
    function sub(uint32 a, uint32 b) internal pure returns (uint32 c) {require((c = a - b) <= a, "BoringMath: Underflow");}
}

// SPDX-License-Identifier: UNLICENSED
// Audit on 5-Jan-2021 by Keno and BoringCrypto

// P1 - P3: OK
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// solhint-disable avoid-low-level-calls

import "./libraries/BoringERC20.sol";

// T1 - T4: OK
contract BaseBoringBatchable {
    function _getRevertMsg(bytes memory _returnData) internal pure returns (string memory) {
        // If the _res length is less than 68, then the transaction failed silently (without a revert message)
        if (_returnData.length < 68) return "Transaction reverted silently";

        assembly {
            // Slice the sighash.
            _returnData := add(_returnData, 0x04)
        }
        return abi.decode(_returnData, (string)); // All that remains is the revert string
    }    
    
    // F3 - F9: OK
    // F1: External is ok here because this is the batch function, adding it to a batch makes no sense
    // F2: Calls in the batch may be payable, delegatecall operates in the same context, so each call in the batch has access to msg.value
    // C1 - C21: OK
    // C3: The length of the loop is fully under user control, so can't be exploited
    // C7: Delegatecall is only used on the same contract, so it's safe
    function batch(bytes[] calldata calls, bool revertOnFail) external payable returns(bool[] memory successes, bytes[] memory results) {
        // Interactions
        successes = new bool[](calls.length);
        results = new bytes[](calls.length);
        for (uint256 i = 0; i < calls.length; i++) {
            (bool success, bytes memory result) = address(this).delegatecall(calls[i]);
            require(success || !revertOnFail, _getRevertMsg(result));
            successes[i] = success;
            results[i] = result;
        }
    }
}

// T1 - T4: OK
contract BoringBatchable is BaseBoringBatchable {
    // F1 - F9: OK
    // F6: Parameters can be used front-run the permit and the user's permit will fail (due to nonce or other revert)
    //     if part of a batch this could be used to grief once as the second call would not need the permit
    // C1 - C21: OK
    function permitToken(IERC20 token, address from, address to, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
        // Interactions
        // X1 - X5
        token.permit(from, to, amount, deadline, v, r, s);
    }
}

// SPDX-License-Identifier: MIT
// Audit on 5-Jan-2021 by Keno and BoringCrypto

// P1 - P3: OK
pragma solidity 0.6.12;

// Source: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol + Claimable.sol
// Edited by BoringCrypto

// T1 - T4: OK
contract BoringOwnableData {
    // V1 - V5: OK
    address public owner;
    // V1 - V5: OK
    address public pendingOwner;
}

// T1 - T4: OK
contract BoringOwnable is BoringOwnableData {
    // E1: OK
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () public {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    // F1 - F9: OK
    // C1 - C21: OK
    function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
        if (direct) {
            // Checks
            require(newOwner != address(0) || renounce, "Ownable: zero address");

            // Effects
            emit OwnershipTransferred(owner, newOwner);
            owner = newOwner;
            pendingOwner = address(0);
        } else {
            // Effects
            pendingOwner = newOwner;
        }
    }

    // F1 - F9: OK
    // C1 - C21: OK
    function claimOwnership() public {
        address _pendingOwner = pendingOwner;
        
        // Checks
        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");

        // Effects
        emit OwnershipTransferred(owner, _pendingOwner);
        owner = _pendingOwner;
        pendingOwner = address(0);
    }

    // M1 - M5: OK
    // C1 - C21: OK
    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }
}

// SPDX-License-Identifier: MIT

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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/Initializable.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

library SignedSafeMath {
    int256 constant private _INT256_MIN = -2**255;

    /**
     * @dev Returns the multiplication of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // 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;
        }

        require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");

        int256 c = a * b;
        require(c / a == b, "SignedSafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two signed 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(int256 a, int256 b) internal pure returns (int256) {
        require(b != 0, "SignedSafeMath: division by zero");
        require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");

        int256 c = a / b;

        return c;
    }

    /**
     * @dev Returns the subtraction of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");

        return c;
    }

    /**
     * @dev Returns the addition of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");

        return c;
    }

    function toUInt256(int256 a) internal pure returns (uint256) {
        require(a >= 0, "Integer < 0");
        return uint256(a);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;
import "@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol";
interface IRewarder {
    using BoringERC20 for IERC20;
    function onLqdrReward(uint256 pid, address user, address recipient, uint256 lqdrAmount, uint256 newLpAmount) external;
    function pendingTokens(uint256 pid, address user, uint256 lqdrAmount) external view returns (IERC20[] memory, uint256[] memory);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol";

interface IMasterChef {
    using BoringERC20 for IERC20;
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. SUSHI to distribute per block.
        uint256 lastRewardBlock;  // Last block number that SUSHI distribution occurs.
        uint256 accSushiPerShare; // Accumulated SUSHI per share, times 1e12. See below.
    }

    function poolInfo(uint256 pid) external view returns (IMasterChef.PoolInfo memory);
    function totalAllocPoint() external view returns (uint256);
    function deposit(uint256 _pid, uint256 _amount) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

interface ILiquidDepositor {
  function treasury() external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;

interface IStrategy {
    function rewards() external view returns (address);

    function gauge() external view returns (address);

    function want() external view returns (address);

    function timelock() external view returns (address);

    function deposit() external;

    function withdrawForSwap(uint256) external returns (uint256);

    function withdraw(address) external returns (uint256);

    function withdraw(uint256) external returns (uint256);

    function skim() external;

    function withdrawAll() external returns (uint256);

    function balanceOf() external view returns (uint256);

    function balanceOfWant() external view returns (uint256);

    function getHarvestable() external view returns (uint256);

    function harvest() external;

    function setTimelock(address) external;

    function setController(address _controller) external;

    function execute(address _target, bytes calldata _data)
        external
        payable
        returns (bytes memory response);

    function execute(bytes calldata _data)
        external
        payable
        returns (bytes memory response);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;

import "../interfaces/IERC20.sol";

library BoringERC20 {
    function safeSymbol(IERC20 token) internal view returns(string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x95d89b41));
        return success && data.length > 0 ? abi.decode(data, (string)) : "???";
    }

    function safeName(IERC20 token) internal view returns(string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x06fdde03));
        return success && data.length > 0 ? abi.decode(data, (string)) : "???";
    }

    function safeDecimals(IERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x313ce567));
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }

    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0xa9059cbb, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0x23b872dd, from, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    // EIP 2612
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;
import "../proxy/Initializable.sol";

/*
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    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;
    }
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT

// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;

import "../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {

    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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);
    }

    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);
            }
        }
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"DepositToLiquidDepositor","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[],"name":"LogInit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IERC20","name":"lpToken","type":"address"},{"indexed":true,"internalType":"contract IRewarder","name":"rewarder","type":"address"}],"name":"LogPoolAddition","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IRewarder","name":"rewarder","type":"address"},{"indexed":false,"internalType":"bool","name":"overwrite","type":"bool"}],"name":"LogSetPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accLqdrPerShare","type":"uint256"}],"name":"LogUpdatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"WithdrawFromLiquidDepositor","type":"event"},{"inputs":[],"name":"ACC_LQDR_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LQDR","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MASTERCHEF_LQDR_PER_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MASTER_CHEF","outputs":[{"internalType":"contract IMasterChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MASTER_PID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"contract IStrategy","name":"_strategy","type":"address"},{"internalType":"uint256","name":"_depositFee","type":"uint256"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestFromMasterChef","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"dummyToken","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_lqdr","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"liquidDepositor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lpToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lqdrPerBlock","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massHarvestFromStrategies","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"pids","type":"uint256[]"}],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingLqdr","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"uint256","name":"accLqdrPerShare","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"depositFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"pools","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewarder","outputs":[{"internalType":"contract IRewarder","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"contract IStrategy","name":"_strategy","type":"address"},{"internalType":"uint256","name":"_depositFee","type":"uint256"},{"internalType":"bool","name":"overwrite","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMasterChef","name":"masterChef","type":"address"},{"internalType":"uint256","name":"masterPid","type":"uint256"},{"internalType":"uint256","name":"masterChefLqdrPerBlock","type":"uint256"}],"name":"setMasterChef","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasuryAddress","type":"address"}],"name":"setTreasuryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategies","outputs":[{"internalType":"contract IStrategy","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"updatePool","outputs":[{"components":[{"internalType":"uint256","name":"accLqdrPerShare","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"depositFee","type":"uint256"}],"internalType":"struct MasterChefV2.PoolInfo","name":"pool","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"int256","name":"rewardDebt","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdrawAndHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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