Contract 0xa249ee8255df0aa00a15262b16bca3efd66c3e4c

/**
 *Submitted for verification at Etherscan.io on 2020-12-16
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

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

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

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

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

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

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

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

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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

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

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

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

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

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

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

// Note that this pool has no minter key of BSD (rewards).
// Instead, the governance will call BSD.distributeReward and send reward to this pool at the beginning.
contract StablesPool {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address public governance;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of BSDs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accBsdPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accBsdPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
        uint256 accumulatedStakingPower; // will accumulate every time user harvest
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        uint256 lastRewardBlock; // Last block number that BSDs distribution occurs.
        uint256 accBsdPerShare; // Accumulated BSDs per share, times 1e18. See below.
    }

    // The BSD TOKEN!
    IERC20 public bsd = IERC20(0x003e0af2916e598Fa5eA5Cb2Da4EDfdA9aEd9Fde);

    // Info of each pool.
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    uint256 public startBlock;

    uint256 public poolLength = 5; // DAI, USDC, USDT, BUSD, ESD

    uint256 public constant BLOCKS_PER_WEEK = 46500;

    uint256[] public epochTotalRewards = [200000 ether, 150000 ether, 100000 ether, 50000 ether];

    // Block number when each epoch ends.
    uint256[4] public epochEndBlocks;

    // Reward per block for each of 4 epochs (last item is equal to 0 - for sanity).
    uint256[5] public epochBsdPerBlock;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event RewardPaid(address indexed user, uint256 amount);

    constructor(
        address _bsd,
        uint256 _startBlock,
        address[] memory _lpTokens
    ) public {
        require(block.number < _startBlock, "late");
        if (_bsd != address(0)) bsd = IERC20(_bsd);
        startBlock = _startBlock; // supposed to be 11,465,000 (Wed Dec 16 2020 15:00:00 UTC)
        epochEndBlocks[0] = startBlock + BLOCKS_PER_WEEK;
        uint256 i;
        for (i = 1; i <= 3; ++i) {
            epochEndBlocks[i] = epochEndBlocks[i - 1] + BLOCKS_PER_WEEK;
        }
        for (i = 0; i <= 3; ++i) {
            epochBsdPerBlock[i] = epochTotalRewards[i].div(BLOCKS_PER_WEEK);
        }
        epochBsdPerBlock[4] = 0;
        if (_lpTokens.length == 0) {
            _addPool(address(0x6B175474E89094C44Da98b954EedeAC495271d0F)); // DAI
            _addPool(address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48)); // USDC
            _addPool(address(0xdAC17F958D2ee523a2206206994597C13D831ec7)); // USDT
            _addPool(address(0x4Fabb145d64652a948d72533023f6E7A623C7C53)); // BUSD
            _addPool(address(0x36F3FD68E7325a35EB768F1AedaAe9EA0689d723)); // ESD
        } else {
            require(_lpTokens.length == poolLength, "Need exactly 5 lpToken address");
            for (i = 0; i < poolLength; ++i) {
                _addPool(_lpTokens[i]);
            }
        }
    }

    // Add a new lp to the pool. Called in the constructor only.
    function _addPool(address _lpToken) internal {
        require(_lpToken != address(0), "!_lpToken");
        poolInfo.push(PoolInfo({lpToken: IERC20(_lpToken), lastRewardBlock: startBlock, accBsdPerShare: 0}));
    }

    // Return reward multiplier over the given _from to _to block.
    function getGeneratedReward(uint256 _from, uint256 _to) public view returns (uint256) {
        for (uint8 epochId = 4; epochId >= 1; --epochId) {
            if (_to >= epochEndBlocks[epochId - 1]) {
                if (_from >= epochEndBlocks[epochId - 1]) return _to.sub(_from).mul(epochBsdPerBlock[epochId]);
                uint256 _generatedReward = _to.sub(epochEndBlocks[epochId - 1]).mul(epochBsdPerBlock[epochId]);
                if (epochId == 1) return _generatedReward.add(epochEndBlocks[0].sub(_from).mul(epochBsdPerBlock[0]));
                for (epochId = epochId - 1; epochId >= 1; --epochId) {
                    if (_from >= epochEndBlocks[epochId - 1]) return _generatedReward.add(epochEndBlocks[epochId].sub(_from).mul(epochBsdPerBlock[epochId]));
                    _generatedReward = _generatedReward.add(epochEndBlocks[epochId].sub(epochEndBlocks[epochId - 1]).mul(epochBsdPerBlock[epochId]));
                }
                return _generatedReward.add(epochEndBlocks[0].sub(_from).mul(epochBsdPerBlock[0]));
            }
        }
        return _to.sub(_from).mul(epochBsdPerBlock[0]);
    }

    // View function to see pending BSDs on frontend.
    function pendingBasisDollar(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accBsdPerShare = pool.accBsdPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
            accBsdPerShare = accBsdPerShare.add(_generatedReward.div(poolLength).mul(1e18).div(lpSupply));
        }
        return user.amount.mul(accBsdPerShare).div(1e18).sub(user.rewardDebt);
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
        pool.accBsdPerShare = pool.accBsdPerShare.add(_generatedReward.div(poolLength).mul(1e18).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens.
    function deposit(uint256 _pid, uint256 _amount) public {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 _pending = user.amount.mul(pool.accBsdPerShare).div(1e18).sub(user.rewardDebt);
            if (_pending > 0) {
                safeBsdTransfer(_sender, _pending);
                emit RewardPaid(_sender, _pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(_sender, address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accBsdPerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

    // Withdraw LP tokens.
    function withdraw(uint256 _pid, uint256 _amount) public {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 _pending = user.amount.mul(pool.accBsdPerShare).div(1e18).sub(user.rewardDebt);
        if (_pending > 0) {
            safeBsdTransfer(_sender, _pending);
            emit RewardPaid(_sender, _pending);
        }
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(_sender, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accBsdPerShare).div(1e18);
        emit Withdraw(_sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    // Safe bsd transfer function, just in case if rounding error causes pool to not have enough BSDs.
    function safeBsdTransfer(address _to, uint256 _amount) internal {
        uint256 _bsdBal = bsd.balanceOf(address(this));
        if (_bsdBal > 0) {
            if (_amount > _bsdBal) {
                bsd.transfer(_to, _bsdBal);
            } else {
                bsd.transfer(_to, _amount);
            }
        }
    }

    function setGovernance(address _governance) external {
        require(msg.sender == governance, "!governance");
        require(_governance != address(0), "zero");
        governance = _governance;
    }

    function governanceRecoverUnsupported(
        IERC20 _token,
        uint256 amount,
        address to
    ) external {
        require(msg.sender == governance, "!governance");
        if (block.number < epochEndBlocks[3] + BLOCKS_PER_WEEK * 12) {
            // do not allow to drain lpToken if less than 3 months after farming
            require(_token != bsd, "!bsd");
            for (uint256 pid = 0; pid < poolLength; ++pid) {
                PoolInfo storage pool = poolInfo[pid];
                require(_token != pool.lpToken, "!pool.lpToken");
            }
        }
        _token.safeTransfer(to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_bsd","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"address[]","name":"_lpTokens","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BLOCKS_PER_WEEK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bsd","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"epochBsdPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"epochEndBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"epochTotalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getGeneratedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"governanceRecoverUnsupported","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingBasisDollar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accBsdPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"accumulatedStakingPower","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000003e0af2916e598fa5ea5cb2da4edfda9aed9fde0000000000000000000000000000000000000000000000000000000000aef128000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000050000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000004fabb145d64652a948d72533023f6e7a623c7c5300000000000000000000000036f3fd68e7325a35eb768f1aedaae9ea0689d723

-----Decoded View---------------
Arg [0] : _bsd (address): 0x003e0af2916e598fa5ea5cb2da4edfda9aed9fde
Arg [1] : _startBlock (uint256): 11465000
Arg [2] : _lpTokens (address[]): 0x36f3fd68e7325a35eb768f1aedaae9ea0689d723

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 000000000000000000000000003e0af2916e598fa5ea5cb2da4edfda9aed9fde
Arg [1] : 0000000000000000000000000000000000000000000000000000000000aef128
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [4] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [5] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [6] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [7] : 0000000000000000000000004fabb145d64652a948d72533023f6e7a623c7c53
Arg [8] : 00000000000000000000000036f3fd68e7325a35eb768f1aedaae9ea0689d723

18314:10155:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19962:29;;;:::i;:::-;;;;;;;;;;;;;;;;19771:26;;;;;;;;;;;;;;;;-1:-1:-1;19771:26:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22442:1139;;;;;;;;;;;;;;;;-1:-1:-1;22442:1139:0;;;;;;;:::i;20230:32::-;;;;;;;;;;;;;;;;-1:-1:-1;20230:32:0;;:::i;25918:809::-;;;;;;;;;;;;;;;;-1:-1:-1;25918:809:0;;;;;;;:::i;:::-;;19928:25;;;:::i;24408:614::-;;;;;;;;;;;;;;;;-1:-1:-1;24408:614:0;;:::i;26798:356::-;;;;;;;;;;;;;;;;-1:-1:-1;26798:356:0;;:::i;27823:643::-;;;;;;;;;;;;;;;;-1:-1:-1;27823:643:0;;;;;;;;;;;;;;;;;;:::i;18410:25::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;19855:64;;;;;;;;;;;;;;;;-1:-1:-1;19855:64:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;20086:92;;;;;;;;;;;;;;;;-1:-1:-1;20086:92:0;;:::i;23644:688::-;;;;;;;;;;;;;;;;-1:-1:-1;23644:688:0;;;;;;;;;:::i;27607:208::-;;;;;;;;;;;;;;;;-1:-1:-1;27607:208:0;;;;:::i;19665:70::-;;;:::i;20357:34::-;;;;;;;;;;;;;;;;-1:-1:-1;20357:34:0;;:::i;25057:825::-;;;;;;;;;;;;;;;;-1:-1:-1;25057:825:0;;;;;;;:::i;20030:47::-;;;:::i;19962:29::-;;;;:::o;19771:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19771:26:0;:::o;22442:1139::-;22519:7;22560:1;22539:978;22574:1;22563:7;:12;;;22539:978;;22614:14;22639:1;22629:7;:11;22614:27;;;;;;;;;;;22607:3;:34;22603:903;;22675:14;22700:1;22690:7;:11;22675:27;;;;;;;;;;;22666:5;:36;22662:94;;22711:45;22730:16;22747:7;22730:25;;;;;;;;;;;22711:14;:3;22719:5;22711:7;:14::i;:::-;:18;;:45::i;:::-;22704:52;;;;;22662:94;22775:24;22802:67;22843:16;22860:7;22843:25;;;;;;;;;;;22802:36;22810:14;22835:1;22825:7;:11;22810:27;;;;;;;;;;;22802:3;;:7;:36::i;:67::-;22775:94;;22892:7;:12;;22903:1;22892:12;22888:100;;;22913:75;22934:53;22967:16;22984:1;22967:19;;;22934:28;22956:5;22934:14;22949:1;22934:17;;;;:21;:28::i;:53::-;22913:16;;:20;:75::i;:::-;22906:82;;;;;;22888:100;23032:1;23022:7;:11;23012:21;;23007:383;23046:1;23035:7;:12;;;23007:383;;23096:14;23121:1;23111:7;:11;23096:27;;;;;;;;;;;23087:5;:36;23083:136;;23132:87;23153:65;23192:16;23209:7;23192:25;;;;;;;;;;;23153:34;23181:5;23153:14;23168:7;23153:23;;;;;;;;23083:136;23261:109;23282:87;23343:16;23360:7;23343:25;;;;;;;;;;;23282:56;23310:14;23335:1;23325:7;:11;23310:27;;;;;;;;;;;23282:14;23297:7;23282:23;;;;;;;;23261:109;23049:9;;;;;23242:128;-1:-1:-1;23007:383:0;;;23415:75;23436:53;23469:16;23486:1;23469:19;;22603:903;22577:9;;22539:978;;;-1:-1:-1;23553:16:0;:19;23534:39;;:14;:3;23542:5;23534:7;:14::i;:39::-;23527:46;;22442:1139;;;;;:::o;20230:32::-;;;;;;;;;;;;;-1:-1:-1;20230:32:0;:::o;25918:809::-;25985:15;26003:10;25985:28;;26024:21;26048:8;26057:4;26048:14;;;;;;;;;;;;;;;;26097;;;26048;26097;;;;;;;:23;;;;;;;;;;;;26139:11;;26048:14;;;;;;;;-1:-1:-1;;;26139:22:0;26131:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26195:16;26206:4;26195:10;:16::i;:::-;26222;26241:67;26292:4;:15;;;26241:46;26282:4;26241:36;26257:4;:19;;;26241:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46::i;:::-;:50;;:67::i;:::-;26222:86;-1:-1:-1;26323:12:0;;26319:128;;26352:34;26368:7;26377:8;26352:15;:34::i;:::-;26406:29;;;;;;;;;;;;;;;;;;;;;;26319:128;26461:11;;26457:140;;26503:11;;:24;;26519:7;26503:15;:24::i;:::-;26489:38;;26542:12;;:43;;:12;;26568:7;26577;26542:25;:43::i;:::-;26641:19;;;;26625:11;;:46;;26666:4;;26625:36;;:15;:36::i;:46::-;26607:15;;;:64;26687:32;;;;;;;;26705:4;;26687:32;;;;;;;;;;;;;25918:809;;;;;;:::o;19928:25::-;;;;:::o;24408:614::-;24460:21;24484:8;24493:4;24484:14;;;;;;;;;;;;;;;;;;24460:38;;24529:4;:20;;;24513:12;:36;24509:75;;24566:7;;;24509:75;24613:12;;:37;;;;;;24644:4;24613:37;;;;;;24594:16;;24613:12;;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24613:37:0;;-1:-1:-1;24665:13:0;24661:102;;-1:-1:-1;24718:12:0;24695:20;;;;:35;24745:7;;24661:102;24773:24;24800:54;24819:4;:20;;;24841:12;24800:18;:54::i;:::-;24773:81;;24887;24911:56;24958:8;24911:42;24948:4;24911:32;24932:10;;24911:16;:20;;:32;;;;:::i;:56::-;24887:19;;;;;:23;:81::i;:::-;24865:19;;;:103;-1:-1:-1;;25002:12:0;24979:20;;;;:35;24408:614;;:::o;26798:356::-;26857:21;26881:8;26890:4;26881:14;;;;;;;;;;;;;;;;26930;;;26881;26930;;;;;;;26945:10;26930:26;;;;;;;;27014:11;;26881:14;;;;;26967:12;;26881:14;;-1:-1:-1;26930:26:0;;26967:59;;26930:26;26967:12;;26945:10;26967:25;:59::i;:::-;27078:11;;27042:48;;;;;;;27072:4;;27060:10;;27042:48;;;;;;;;;27115:1;27101:15;;;27127;;;;:19;-1:-1:-1;;26798:356:0:o;27823:643::-;27980:10;;;;27966;:24;27958:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28036:17;;28056:20;28036:40;28021:12;:55;28017:400;;;28193:3;;;28183:13;;;28193:3;;28183:13;;28175:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28225:11;28220:186;28248:10;;28242:3;:16;28220:186;;;28286:21;28310:8;28319:3;28310:13;;;;;;;;;;;;;;;;;;;;;28360:12;;28310:13;;-1:-1:-1;28360:12:0;28350:22;;;28360:12;;28350:22;;28342:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28260:5:0;;28220:186;;;;28017:400;28427:31;:19;;;28447:2;28451:6;28427:19;:31::i;:::-;27823:643;;;:::o;18410:25::-;;;;;;:::o;19855:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;20086:92::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20086:92:0;:::o;23644:688::-;23724:7;23744:21;23768:8;23777:4;23768:14;;;;;;;;;;;;;;;;23817;;;23768;23817;;;;;;;:21;;;;;;;;;;;;23874:19;23768:14;;;;;;;23874:19;;;;23923:12;;:37;;;;;23954:4;23923:37;;;;;;23768:14;;-1:-1:-1;23817:21:0;;23874:19;;23768:14;;23923:12;;;:22;;:37;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23923:37:0;23990:20;;;;23923:37;;-1:-1:-1;23975:12:0;:35;:52;;;;-1:-1:-1;24014:13:0;;;23975:52;23971:274;;;24044:24;24071:54;24090:4;:20;;;24112:12;24071:18;:54::i;:::-;24044:81;;24157:76;24176:56;24223:8;24176:42;24213:4;24176:32;24197:10;;24176:16;:20;;:32;;;;:::i;:56::-;24157:14;;:18;:76::i;:::-;24140:93;;23971:274;;24262:62;24308:4;:15;;;24262:41;24298:4;24262:31;24278:14;24262:4;:11;;;:15;;:31;;;;:::i;:62::-;24255:69;23644:688;-1:-1:-1;;;;;;;23644:688:0:o;27607:208::-;27693:10;;;;27679;:24;27671:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27738:25;;;27730:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27783:10;:24;;;;;;;;;;;;;;;27607:208::o;19665:70::-;;;;;;:::o;20357:34::-;;;;;;;;;25057:825;25123:15;25141:10;25123:28;;25162:21;25186:8;25195:4;25186:14;;;;;;;;;;;;;;;;25235;;;25186;25235;;;;;;;:23;;;;;;;;;;;;25186:14;;;;;;-1:-1:-1;25269:16:0;25244:4;25269:10;:16::i;:::-;25300:11;;:15;25296:288;;25332:16;25351:67;25402:4;:15;;;25351:46;25392:4;25351:36;25367:4;:19;;;25351:4;:11;;;:15;;:36;;;;:::i;:67::-;25332:86;-1:-1:-1;25437:12:0;;25433:140;;25470:34;25486:7;25495:8;25470:15;:34::i;:::-;25528:29;;;;;;;;;;;;;;;;;;;;;;25433:140;25296:288;;25598:11;;25594:159;;25626:12;;:62;;:12;;25656:7;25673:4;25680:7;25626:29;:62::i;:::-;25717:11;;:24;;25733:7;25717:15;:24::i;:::-;25703:38;;25594:159;25797:19;;;;25781:11;;:46;;25822:4;;25781:36;;:15;:36::i;:46::-;25763:15;;;:64;25843:31;;;;;;;;25860:4;;25843:31;;;;;;;;;;;;;25057:825;;;;;:::o;20030:47::-;20072:5;20030:47;:::o;5984:132::-;6042:7;6069:39;6073:1;6076;6069:39;;;;;;;;;;;;;;;;;:3;:39::i;4113:136::-;4171:7;4198:43;4202:1;4205;4198:43;;;;;;;;;;;;;;;;;:3;:43::i;5037:471::-;5095:7;5340:6;5336:47;;-1:-1:-1;5370:1:0;5363:8;;5336:47;5407:5;;;5411:1;5407;:5;:1;5431:5;;;;;:10;5423:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3649:181;3707:7;3739:5;;;3763:6;;;;3755:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27266:333;27359:3;;:28;;;;;;27381:4;27359:28;;;;;;27341:15;;27359:3;;;:13;;:28;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27359:28:0;;-1:-1:-1;27402:11:0;;27398:194;;27444:7;27434;:17;27430:151;;;27472:3;;:26;;;;;;:3;:26;;;;;;;;;;;;;;;:3;;;;;:12;;:26;;;;;;;;;;;;;;:3;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27430:151:0;;-1:-1:-1;27430:151:0;;27539:3;;:26;;;;;;:3;:26;;;;;;;;;;;;;;;:3;;;;;:12;;:26;;;;;;;;;;;;;;:3;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;27266:333:0;;;:::o;14906:211::-;15050:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15073:23;15050:58;;;15023:86;;15043:5;;15023:19;:86::i;15125:248::-;15296:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15319:27;15296:68;;;15269:96;;15289:5;;15269:19;:96::i;:::-;15125:248;;;;:::o;6612:312::-;6732:7;6767:12;6760:5;6752:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6791:9;6807:1;6803;:5;;;;;;;6612:312;-1:-1:-1;;;;;6612:312:0:o;4552:226::-;4672:7;4708:12;4700:6;;;;4692:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4744:5:0;;;4552:226::o;17367:774::-;17791:23;17817:69;17845:4;17817:69;;;;;;;;;;;;;;;;;17825:5;17817:27;;;;:69;;;;;:::i;:::-;17901:17;;17791:95;;-1:-1:-1;17901:21:0;17897:237;;18056:10;18045:30;;;;;;;;;;;;;;;-1:-1:-1;18045:30:0;18037:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11832:230;11969:12;12001:53;12024:6;12032:4;12038:1;12041:12;12001:22;:53::i;:::-;11994:60;11832:230;-1:-1:-1;;;;11832:230:0:o;13320:1020::-;13493:12;13526:18;13537:6;13526:10;:18::i;:::-;13518:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13652:12;13666:23;13693:6;:11;;13712:8;13722:4;13693:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13651:76;;;;13742:7;13738:595;;;13773:10;-1:-1:-1;13766:17:0;;-1:-1:-1;13766:17:0;13738:595;13887:17;;:21;13883:439;;14150:10;14144:17;14211:15;14198:10;14194:2;14190:19;14183:44;14098:148;14286:20;;;;;;;;;;;;;;;;;;;;14293:12;;14286:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8892:444;9272:20;9320:8;;;8892:444::o

ipfs://8b196828e65c1d6ea76812c88b34e326c4437e592aa9cf7405cfb773049aac08