{
    "Function": "slitherConstructorVariables",
    "File": "contracts/MasterChef.sol",
    "Parent Contracts": [
        "node_modules/@openzeppelin/contracts/security/ReentrancyGuard.sol",
        "node_modules/@openzeppelin/contracts/access/Ownable.sol",
        "node_modules/@openzeppelin/contracts/utils/Context.sol"
    ],
    "High-Level Calls": [],
    "Internal Calls": [],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "contract MasterChef is Ownable, ReentrancyGuard {\n    using SafeMath for uint;\n    using SafeERC20 for IERC20;\n\n    event Deposit(address indexed _user, uint indexed _pid, uint _amount);\n    event Withdraw(address indexed _user, uint indexed _pid, uint _amount);\n    event EmergencyWithdraw(address indexed user, uint indexed _pid, uint _amount);\n\n    struct UserInfo {\n        uint128 amount; // How many tokens the user has provided.\n        uint128 rewardDebt; // Reward debt. See explanation below.\n        //\n        // We do some fancy math here. Basically, any point in time, the amount of RADSs\n        // entitled to a user but is pending to be distributed is:\n        //\n        //   pending reward = (user.amount * pool.accumlatedConcurPerShare) - user.rewardDebt\n        //\n        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:\n        //   1. The pool's `accumlatedConcurPerShare` (and `lastRewardBlock`) gets updated.\n        //   2. User receives the pending reward sent to his/her address.\n        //   3. User's `amount` gets updated.\n        //   4. User's `rewardDebt` gets updated.\n    }\n\n    // Info of each pool.\n    struct PoolInfo {\n        IERC20 depositToken; // Address of LP token contract.\n        uint allocPoint; // How many allocation points assigned to this pool. to distribute per block.\n        uint lastRewardBlock; // Last block number that distribution occurs.\n        uint accConcurPerShare; // Accumulated per share, times multiplier. See below.\n        uint16 depositFeeBP; // Deposit fee in basis points\n    }\n\n    PoolInfo[] public poolInfo;\n    mapping(uint => mapping(address => UserInfo)) public userInfo; // Info of each user that stakes LP tokens.\n    mapping(address => bool) public isDepositor;\n    mapping(address => uint256) public pid; // pid mapped to token\n    uint public concurPerBlock = 100000 gwei; // concur tokens transferred per block\n    uint public totalAllocPoint = 0; // Total allocation points. Must be the sum of all allocation points in all pools.\n    uint public startBlock;\n    uint public endBlock; // The block number when mining starts.\n    IERC20 public concur;\n\n    uint private _concurShareMultiplier = 1e18;\n    uint private _perMille = 1000; // 100%\n\n    constructor(IERC20 _concur, uint _startBlock, uint _endBlock) Ownable() {\n        startBlock = _startBlock;\n        endBlock = _endBlock;\n        concur = _concur;\n        poolInfo.push(\n            PoolInfo({\n            depositToken: IERC20(address(0)),\n            allocPoint : 0,\n            lastRewardBlock : _startBlock,\n            accConcurPerShare : 0,\n            depositFeeBP : 0\n        }));\n    }\n\n    modifier onlyDepositor() {\n        require(isDepositor[msg.sender], \"!depositor\");\n        _;\n    }\n\n    function addDepositor(address _depositor) external onlyOwner {\n        isDepositor[_depositor] = true;\n    }\n\n    function removeDepositor(address _depositor) external onlyOwner {\n        isDepositor[_depositor] = false;\n    }\n\n    function add(address _token, uint _allocationPoints, uint16 _depositFee, uint _startBlock) public onlyOwner {\n        require(_token != address(0), \"zero address\");\n        uint lastRewardBlock = block.number > _startBlock ? block.number : _startBlock;\n        totalAllocPoint = totalAllocPoint.add(_allocationPoints);\n        require(pid[_token] == 0, \"already registered\"); // pid starts from 0\n        poolInfo.push(\n            PoolInfo({\n                depositToken: IERC20(_token),\n                allocPoint: _allocationPoints,\n                lastRewardBlock: lastRewardBlock,\n                accConcurPerShare: 0,\n                depositFeeBP: _depositFee\n            })\n        );\n        pid[_token] = poolInfo.length - 1;\n    }\n\n    function poolLength() external view returns (uint) {\n        return poolInfo.length;\n    }\n\n    // Return reward multiplier over the given _from to _to block.\n    function getMultiplier(uint _from, uint _to) public pure returns (uint) {\n        return _to.sub(_from);\n    }\n\n    // View function to see pending [concur] on frontend.\n    function pendingConcur(uint _pid, address _user) external view returns (uint) {\n        PoolInfo storage pool = poolInfo[_pid];\n        UserInfo storage user = userInfo[_pid][_user];\n        uint accConcurPerShare = pool.accConcurPerShare;\n        uint lpSupply = pool.depositToken.balanceOf(address(this));\n        if (block.number > pool.lastRewardBlock && lpSupply != 0) {\n            uint multiplier = getMultiplier(pool.lastRewardBlock, block.number);\n            uint concurReward = multiplier.mul(concurPerBlock).mul(pool.allocPoint).div(totalAllocPoint);\n            accConcurPerShare = accConcurPerShare.add(concurReward.mul(_concurShareMultiplier).div(lpSupply));\n        }\n        return user.amount * accConcurPerShare / _concurShareMultiplier - user.rewardDebt;\n    }\n\n    // Update reward variables for all pools. Be careful of gas spending!\n    function massUpdatePools() public {\n        uint length = poolInfo.length;\n        for (uint _pid = 0; _pid < length; ++_pid) {\n            updatePool(_pid);\n        }\n    }\n\n    // Update reward variables of the given pool to be up-to-date.\n    function updatePool(uint _pid) public {\n        PoolInfo storage pool = poolInfo[_pid];\n        if (block.number <= pool.lastRewardBlock) {\n            return;\n        }\n        uint lpSupply = pool.depositToken.balanceOf(address(this));\n        if (lpSupply == 0 || pool.allocPoint == 0) {\n            pool.lastRewardBlock = block.number;\n            return;\n        }\n        if(block.number >= endBlock) {\n            pool.lastRewardBlock = block.number;\n            return;\n        }        \n\n        uint multiplier = getMultiplier(pool.lastRewardBlock, block.number);\n        uint concurReward = multiplier.mul(concurPerBlock).mul(pool.allocPoint).div(totalAllocPoint);\n        pool.accConcurPerShare = pool.accConcurPerShare.add(concurReward.mul(_concurShareMultiplier).div(lpSupply));\n        pool.lastRewardBlock = block.number;\n    }\n\n    // Deposit tokens for [concur] allocation.  \n    function deposit(address _recipient, uint _pid, uint _amount) external nonReentrant onlyDepositor {\n        PoolInfo storage pool = poolInfo[_pid];\n        UserInfo storage user = userInfo[_pid][_msgSender()];\n        updatePool(_pid);\n       \n        if(user.amount > 0) {  \n            uint pending = user.amount * pool.accConcurPerShare / _concurShareMultiplier - user.rewardDebt;\n            if (pending > 0) {\n                safeConcurTransfer(_recipient, pending);\n            }\n        }\n\n        if (_amount > 0) {\n            if (pool.depositFeeBP > 0) {\n                uint depositFee = _amount.mul(pool.depositFeeBP).div(_perMille);\n                user.amount = SafeCast.toUint128(user.amount + _amount - depositFee);\n            } else {\n                user.amount = SafeCast.toUint128(user.amount + _amount);\n            }\n        }     \n\n        user.rewardDebt = SafeCast.toUint128(user.amount * pool.accConcurPerShare / _concurShareMultiplier);\n        emit Deposit(_recipient, _pid, _amount);\n    }\n\n    // Withdraw tokens\n    function withdraw(address _recipient, uint _pid, uint _amount) external nonReentrant onlyDepositor {\n        PoolInfo storage pool = poolInfo[_pid];\n        UserInfo storage user = userInfo[_pid][_msgSender()];\n        require(user.amount > 0, \"MasterChef: nothing to withdraw\");\n        require(user.amount >= _amount, \"MasterChef: withdraw not allowed\");\n        updatePool(_pid);\n\n        uint pending = user.amount * pool.accConcurPerShare / _concurShareMultiplier - user.rewardDebt;\n        if(pending > 0) {\n            safeConcurTransfer(_recipient, pending);\n        }\n        if (_amount > 0) {\n            user.amount = SafeCast.toUint128(user.amount - _amount);\n        }\n        user.rewardDebt = SafeCast.toUint128(user.amount * pool.accConcurPerShare / _concurShareMultiplier);\n        emit Withdraw(_recipient, _pid, _amount);\n    }\n\n    // Safe [concur] transfer function, just in case if rounding error causes pool to not have enough\n    function safeConcurTransfer(address _to, uint _amount) private {\n        uint concurBalance = concur.balanceOf(address(this));\n        bool transferSuccess = false;\n        if (_amount > concurBalance) {\n            transferSuccess = concur.transfer(_to, concurBalance);\n        } else {\n            transferSuccess = concur.transfer(_to, _amount);\n        }\n        require(transferSuccess, \"safeConcurTransfer: transfer failed\");\n    }\n}"
}