Farseen0/scar-pairs huggingface dataset:
HIGH severity: Vulnerable function: ```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\. ```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\n        uint8 operatorId,\n        IRioLRTOperatorRegistry.StrategyShareCap memory newShareCap\n    ) internal {\n        . \n        // @review this "if" will be executed\n        -> if (currentShar

Vulnerable code:
```\nfunction setOperatorStrategyCap(\n        RioLRTOperatorRegistryStorageV1.StorageV1 storage s,\n        uint8 operatorId,\n        IRioLRTOperatorRegistry.StrategyShareCap memory newShareCap\n    ) internal {\n        . \n        // @review this "if" will be executed\n        -> if (currentShareDetails.cap > 0 && newShareCap.cap == 0) {\n            // If the operator has allocations, queue them for exit.\n            if (currentShareDetails.allocation > 0) {\n                -> operatorDetails.queueOperatorStrategyExit(operatorId, newShareCap.strategy);\n            }\n            // Remove the operator from the utilization heap.\n            utilizationHeap.removeByID(operatorId);\n        } else if (currentShareDetails.cap == 0 && newShareCap.cap > 0) {\n            // If the current cap is 0 and the new cap is greater than 0, insert the operator into the heap.\n            utilizationHeap.insert(OperatorUtilizationHeap.Operator(operatorId, 0));\n        } else {\n            // Otherwise, update the operator's utilization in the heap.\n            utilizationHeap.updateUtilizationByID(operatorId, currentShareDetails.allocation.divWad(newShareCap.cap));\n        }\n        .\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: AccountFacet.sol\n    function withdraw(uint256 amount) external whenNotAccountingPaused . ```\nFile: AccountFacet.sol\n    function withdraw(uint256 amount) external whenNotAccountingPaused notSuspended(msg.sender) {\n        AccountFacetImpl.withdraw(msg.sender, amount);\n        emit Withdraw(msg.sender, msg.sender, amount);\n    }\n\n    function withdrawTo(\n        address user,\n  

Vulnerable code:
```\nFile: AccountFacet.sol\n    function withdraw(uint256 amount) external whenNotAccountingPaused notSuspended(msg.sender) {\n        AccountFacetImpl.withdraw(msg.sender, amount);\n        emit Withdraw(msg.sender, msg.sender, amount);\n    }\n\n    function withdrawTo(\n        address user,\n        uint256 amount\n    ) external whenNotAccountingPaused notSuspended(msg.sender) {\n        AccountFacetImpl.withdraw(user, amount);\n        emit Withdraw(msg.sender, user, amount);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction switchMaintainerFee(\n DataStoreUtils.DataStore storage DATASTORE,\n uint256 id,\n uin. ```\nfunction switchMaintainerFee(\n DataStoreUtils.DataStore storage DATASTORE,\n uint256 id,\n uint256 newFee\n) external {\n DATASTORE.writeUintForId(\n id,\n "priorFee",\n DATASTORE.readUintForId(id, "fee")\n );\n DATASTORE.writeUintForId(\n id,\n "feeSwitch",\n block.timestamp + FEE\_SWITCH\_LA

Vulnerable code:
```\nfunction switchMaintainerFee(\n DataStoreUtils.DataStore storage DATASTORE,\n uint256 id,\n uint256 newFee\n) external {\n DATASTORE.writeUintForId(\n id,\n "priorFee",\n DATASTORE.readUintForId(id, "fee")\n );\n DATASTORE.writeUintForId(\n id,\n "feeSwitch",\n block.timestamp + FEE\_SWITCH\_LATENCY\n );\n DATASTORE.writeUintForId(id, "fee", newFee);\n\n emit MaintainerFeeSwitched(\n id,\n newFee,\n block.timestamp + FEE\_SWITCH\_LATENCY\n );\n}\n```\n
HIGH severity: Vulnerable function: ```\nFile: Boosted3TokenAuraVault.sol\n    function getEmergencySettlementBPTAmount(uint256 maturity. ```\nFile: Boosted3TokenAuraVault.sol\n    function getEmergencySettlementBPTAmount(uint256 maturity) external view returns (uint256 bptToSettle) {\n        Boosted3TokenAuraStrategyContext memory context = _strategyContext();\n        bptToSettle = context.baseStrategy._getEmergencySettlementParams

Vulnerable code:
```\nFile: Boosted3TokenAuraVault.sol\n    function getEmergencySettlementBPTAmount(uint256 maturity) external view returns (uint256 bptToSettle) {\n        Boosted3TokenAuraStrategyContext memory context = _strategyContext();\n        bptToSettle = context.baseStrategy._getEmergencySettlementParams({\n            maturity: maturity, \n            totalBPTSupply: IERC20(context.poolContext.basePool.basePool.pool).totalSupply()\n        });\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n        if (isMint) {\n            /// @dev Mint cvgSdt 1:1 via CvgToke con. ```\n        if (isMint) {\n            /// @dev Mint cvgSdt 1:1 via CvgToke contract\n            cvgSdt.mint(receiver, rewardAmount);\n        } else {\n            ICrvPoolPlain _poolCvgSDT = poolCvgSDT;\n            /// @dev Only swap if the returned amount in CvgSdt is gretear than the amount r

Vulnerable code:
```\n        if (isMint) {\n            /// @dev Mint cvgSdt 1:1 via CvgToke contract\n            cvgSdt.mint(receiver, rewardAmount);\n        } else {\n            ICrvPoolPlain _poolCvgSDT = poolCvgSDT;\n            /// @dev Only swap if the returned amount in CvgSdt is gretear than the amount rewarded in SDT\n            _poolCvgSDT.exchange(0, 1, rewardAmount, _poolCvgSDT.get_dy(0, 1, rewardAmount), receiver);\n        }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction hasRole(bytes32 role, address account)\n    public\n    view\n    virtual\n    overrid. ```\nfunction hasRole(bytes32 role, address account)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n{\n    return\n        super.hasRole(ADMIN_ROLE, account) || super.hasRole(role, account);\n}\n```\n

Vulnerable code:
```\nfunction hasRole(bytes32 role, address account)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n{\n    return\n        super.hasRole(ADMIN_ROLE, account) || super.hasRole(role, account);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\n    struct LiquidationVars {\n        // address token;\n        // uint256. ```\n    struct LiquidationVars {\n        // address token;\n        // uint256 tokenPrice;\n        // uint256 coinValue;\n        uint256 borrowerCollateralValue;\n        // uint256 tokenAmount;\n        // uint256 tokenDivisor;\n        uint256 msgTotalBorrow;\n```\n

Vulnerable code:
```\n    struct LiquidationVars {\n        // address token;\n        // uint256 tokenPrice;\n        // uint256 coinValue;\n        uint256 borrowerCollateralValue;\n        // uint256 tokenAmount;\n        // uint256 tokenDivisor;\n        uint256 msgTotalBorrow;\n```\n
MEDIUM severity: Vulnerable function: ```\n        function submitProposal(uint8 _actionType, bytes memory _payload)  public onlyCouncil {. ```\n        function submitProposal(uint8 _actionType, bytes memory _payload)  public onlyCouncil {\n             uint256 proposalId = proposalCount;\n                 proposals[proposalId] = Proposal(msg.sender,_actionType, \n                    _payload, 0, false);\n                proposalCount 

Vulnerable code:
```\n        function submitProposal(uint8 _actionType, bytes memory _payload)  public onlyCouncil {\n             uint256 proposalId = proposalCount;\n                 proposals[proposalId] = Proposal(msg.sender,_actionType, \n                    _payload, 0, false);\n                proposalCount += 1;\n         emit ProposalSubmitted(proposalId, msg.sender);\n        }\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: CollateralManager.sol\n\n       } else if (tellerV2.isLoanDefaulted(_. ```\nFile: CollateralManager.sol\n\n       } else if (tellerV2.isLoanDefaulted(_bidId)) {\n           _withdraw(_bidId, tellerV2.getLoanLender(_bidId)); // sends collateral to lender\n           emit CollateralClaimed(_bidId);\n       } else {\n```\n

Vulnerable code:
```\nFile: CollateralManager.sol\n\n       } else if (tellerV2.isLoanDefaulted(_bidId)) {\n           _withdraw(_bidId, tellerV2.getLoanLender(_bidId)); // sends collateral to lender\n           emit CollateralClaimed(_bidId);\n       } else {\n```\n
MEDIUM severity: Vulnerable function: ```\nuint256 currentRewardGlobal = _getCurrentReward(positionState_.asset);\nuin. ```\nuint256 currentRewardGlobal = _getCurrentReward(positionState_.asset);\nuint256 deltaReward = currentRewardGlobal - assetState_.lastRewardGlobal; ❌\n```\n

Vulnerable code:
```\nuint256 currentRewardGlobal = _getCurrentReward(positionState_.asset);\nuint256 deltaReward = currentRewardGlobal - assetState_.lastRewardGlobal; ❌\n```\n
MEDIUM severity: Vulnerable function: ```\n    function getBorrowRatePerBlock(address \_token) public view returns(uint) {\n        if(!gl. ```\n    function getBorrowRatePerBlock(address \_token) public view returns(uint) {\n        if(!globalConfig.tokenInfoRegistry().isSupportedOnCompound(\_token))\n        // If the token is NOT supported by the third party, borrowing rate = 3% + U \* 15%.\n            return getCapitalUtilizationRa

Vulnerable code:
```\n    function getBorrowRatePerBlock(address \_token) public view returns(uint) {\n        if(!globalConfig.tokenInfoRegistry().isSupportedOnCompound(\_token))\n        // If the token is NOT supported by the third party, borrowing rate = 3% + U \* 15%.\n            return getCapitalUtilizationRatio(\_token).mul(globalConfig.rateCurveSlope()).div(INT\_UNIT).add(globalConfig.rateCurveConstant()).div(BLOCKS\_PER\_YEAR);\n\n        // if the token is suppored in third party, borrowing rate = Compound Supply Rate \* 0.4 + Compound Borrow Rate \* 0.6\n        return (compoundPool[\_token].depositRatePerBlock).mul(globalConfig.compoundSupplyRateWeights()).\n            add((compoundPool[\_token].borrowRatePerBlock).mul(globalConfig.compoundBorrowRateWeights())).div(10);\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n- Slashing risk\n\nETH 2.0 validators risk staking penalties, with up to 10. ```\n- Slashing risk\n\nETH 2.0 validators risk staking penalties, with up to 100% of staked funds at risk if validators fail. To minimise this risk, Lido stakes across multiple professional and reputable node operators with heterogeneous setups, with additional mitigation in the form of insurance t

Vulnerable code:
```\n- Slashing risk\n\nETH 2.0 validators risk staking penalties, with up to 100% of staked funds at risk if validators fail. To minimise this risk, Lido stakes across multiple professional and reputable node operators with heterogeneous setups, with additional mitigation in the form of insurance that is paid from Lido fees.\n\n- stETH price risk\n\nUsers risk an exchange price of stETH which is lower than inherent value due to withdrawal restrictions on Lido, making arbitrage and risk-free market-making impossible. \n\nThe Lido DAO is driven to mitigate above risks and eliminate them entirely to the extent possible. Despite this, they may still exist and, as such, it is our duty to communicate them.\n```\n
HIGH severity: Vulnerable function: ```\n_withholdTau((tauReturned * _rewardProportion) / Constants.PERCENT_PRECISIO. ```\n_withholdTau((tauReturned * _rewardProportion) / Constants.PERCENT_PRECISION);\n```\n

Vulnerable code:
```\n_withholdTau((tauReturned * _rewardProportion) / Constants.PERCENT_PRECISION);\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _claimEpochRewards(uint48 epoch_) internal returns (uint256) {\n// rest of code\n . ```\n    function _claimEpochRewards(uint48 epoch_) internal returns (uint256) {\n// rest of code\n      uint256 rewards = ((rewardsPerTokenEnd - userRewardsClaimed) * stakeBalance[msg.sender]) /\n            10 ** stakedTokenDecimals;\n        // Mint the option token on the teller\n        // This

Vulnerable code:
```\n    function _claimEpochRewards(uint48 epoch_) internal returns (uint256) {\n// rest of code\n      uint256 rewards = ((rewardsPerTokenEnd - userRewardsClaimed) * stakeBalance[msg.sender]) /\n            10 ** stakedTokenDecimals;\n        // Mint the option token on the teller\n        // This transfers the reward amount of payout tokens to the option teller in exchange for the amount of option tokens\n        payoutToken.approve(address(optionTeller), rewards);\n        optionTeller.create(optionToken, rewards);\n```\n
MEDIUM severity: Vulnerable function: ```\n    function _accumulateInternalRewards() internal view returns (uint256[] memory) {\n        u. ```\n    function _accumulateInternalRewards() internal view returns (uint256[] memory) {\n        uint256 numInternalRewardTokens = internalRewardTokens.length;\n        uint256[] memory accumulatedInternalRewards = new uint256[](numInternalRewardTokens);\n\n\n        for (uint256 i; i < numInterna

Vulnerable code:
```\n    function _accumulateInternalRewards() internal view returns (uint256[] memory) {\n        uint256 numInternalRewardTokens = internalRewardTokens.length;\n        uint256[] memory accumulatedInternalRewards = new uint256[](numInternalRewardTokens);\n\n\n        for (uint256 i; i < numInternalRewardTokens; ) {\n            InternalRewardToken memory rewardToken = internalRewardTokens[i];\n\n\n            uint256 totalRewards;\n            if (totalLP > 0) {\n                uint256 timeDiff = block.timestamp - rewardToken.lastRewardTime;\n                totalRewards = (timeDiff * rewardToken.rewardsPerSecond);\n            }\n\n\n            accumulatedInternalRewards[i] = totalRewards;\n\n\n            unchecked {\n                ++i;\n            }\n        }\n\n\n        return accumulatedInternalRewards;\n    }\n```\n
MEDIUM severity: Vulnerable function: ```\n      if (withdrawalValue < lpParams.minDepositWithdraw && \n          amou. ```\n      if (withdrawalValue < lpParams.minDepositWithdraw && \n          amountLiquidityToken < lpParams.minDepositWithdraw) {\n      revert MinimumWithdrawNotMet(address(this), withdrawalValue, lpParams.minDepositWithdraw);\n      }\n```\n

Vulnerable code:
```\n      if (withdrawalValue < lpParams.minDepositWithdraw && \n          amountLiquidityToken < lpParams.minDepositWithdraw) {\n      revert MinimumWithdrawNotMet(address(this), withdrawalValue, lpParams.minDepositWithdraw);\n      }\n```\n
MEDIUM severity: Vulnerable function: ```\n        _addCategory(toCategory("protocol-owned-treasury"), true, 0xb600c5e. ```\n        _addCategory(toCategory("protocol-owned-treasury"), true, 0xb600c5e2, 0x00000000); // getProtocolOwnedTreasuryOhm()`\n```\n

Vulnerable code:
```\n        _addCategory(toCategory("protocol-owned-treasury"), true, 0xb600c5e2, 0x00000000); // getProtocolOwnedTreasuryOhm()`\n```\n
MEDIUM severity: Vulnerable function: ```\n            uint256 entitledShares = previewWithdraw(\n                queu. ```\n            uint256 entitledShares = previewWithdraw(\n                queue[index].epochId,\n                queue[index].assets\n            );\n            // mint only if user won epoch he is rolling over\n            if (entitledShares > queue[index].assets) {\n```\n

Vulnerable code:
```\n            uint256 entitledShares = previewWithdraw(\n                queue[index].epochId,\n                queue[index].assets\n            );\n            // mint only if user won epoch he is rolling over\n            if (entitledShares > queue[index].assets) {\n```\n
MEDIUM severity: Vulnerable function: ```\nFile: PartyAFacetImpl.sol\n    function forceClosePosition(uint256 quoteId, PairUpnlAndPriceSig. ```\nFile: PartyAFacetImpl.sol\n    function forceClosePosition(uint256 quoteId, PairUpnlAndPriceSig memory upnlSig) internal {\n        AccountStorage.Layout storage accountLayout = AccountStorage.layout();\n        MAStorage.Layout storage maLayout = MAStorage.layout();\n        Quote storage quot

Vulnerable code:
```\nFile: PartyAFacetImpl.sol\n    function forceClosePosition(uint256 quoteId, PairUpnlAndPriceSig memory upnlSig) internal {\n        AccountStorage.Layout storage accountLayout = AccountStorage.layout();\n        MAStorage.Layout storage maLayout = MAStorage.layout();\n        Quote storage quote = QuoteStorage.layout().quotes[quoteId];\n\n        uint256 filledAmount = quote.quantityToClose;\n        require(quote.quoteStatus == QuoteStatus.CLOSE_PENDING, "PartyAFacet: Invalid state");\n        require(\n            block.timestamp > quote.modifyTimestamp + maLayout.forceCloseCooldown,\n            "PartyAFacet: Cooldown not reached"\n        );\n..SNIP..\n```\n
HIGH severity: Vulnerable function: ```\nfunction claimDefaulted(uint256 loanID_) external returns (uint256, uint256, uint256) {\n  Loan. ```\nfunction claimDefaulted(uint256 loanID_) external returns (uint256, uint256, uint256) {\n  Loan memory loan = loans[loanID_];\n  delete loans[loanID_];\n```\n

Vulnerable code:
```\nfunction claimDefaulted(uint256 loanID_) external returns (uint256, uint256, uint256) {\n  Loan memory loan = loans[loanID_];\n  delete loans[loanID_];\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction provideRedemptionSignature(\n    DepositUtils.Deposit storage \_d,\n    uint8 \_v,\n  . ```\nfunction provideRedemptionSignature(\n    DepositUtils.Deposit storage \_d,\n    uint8 \_v,\n    bytes32 \_r,\n    bytes32 \_s\n) public {\n    require(\_d.inAwaitingWithdrawalSignature(), "Not currently awaiting a signature");\n\n    // If we're outside of the signature window, we COULD punish

Vulnerable code:
```\nfunction provideRedemptionSignature(\n    DepositUtils.Deposit storage \_d,\n    uint8 \_v,\n    bytes32 \_r,\n    bytes32 \_s\n) public {\n    require(\_d.inAwaitingWithdrawalSignature(), "Not currently awaiting a signature");\n\n    // If we're outside of the signature window, we COULD punish signers here\n    // Instead, we consider this a no-harm-no-foul situation.\n    // The signers have not stolen funds. Most likely they've just inconvenienced someone\n\n    // The signature must be valid on the pubkey\n    require(\n        \_d.signerPubkey().checkSig(\n            \_d.lastRequestedDigest,\n            \_v, \_r, \_s\n        ),\n        "Invalid signature"\n    );\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction withdraw(uint256 _amount) external {//@audit-info LSD token\n    if (_amount == 0) rev. ```\nfunction withdraw(uint256 _amount) external {//@audit-info LSD token\n    if (_amount == 0) revert InvalidAmount();\n    IERC20Upgradeable(address(stakingPool)).safeTransferFrom(msg.sender, address(this), _amount);//@audit-info get LSD token from the user\n    _withdraw(msg.sender, _amount);\n}

Vulnerable code:
```\nfunction withdraw(uint256 _amount) external {//@audit-info LSD token\n    if (_amount == 0) revert InvalidAmount();\n    IERC20Upgradeable(address(stakingPool)).safeTransferFrom(msg.sender, address(this), _amount);//@audit-info get LSD token from the user\n    _withdraw(msg.sender, _amount);\n}\n```\n
MEDIUM severity: Vulnerable function: ```\npragma solidity ^0.5.2;\npragma experimental ABIEncoderV2; // to enable str. ```\npragma solidity ^0.5.2;\npragma experimental ABIEncoderV2; // to enable structure-type parameters\n```\n

Vulnerable code:
```\npragma solidity ^0.5.2;\npragma experimental ABIEncoderV2; // to enable structure-type parameters\n```\n
HIGH severity: Vulnerable function: ```\nfunction _handleStrategistInterestReward(uint256 lienId, uint256 amount)\n    internal\n    vir. ```\nfunction _handleStrategistInterestReward(uint256 lienId, uint256 amount)\n    internal\n    virtual\n    override\n  {\n    if (VAULT_FEE() != uint256(0)) {\n      uint256 interestOwing = LIEN_TOKEN().getInterest(lienId);\n      uint256 x = (amount > interestOwing) ? interestOwing : amount;\n  

Vulnerable code:
```\nfunction _handleStrategistInterestReward(uint256 lienId, uint256 amount)\n    internal\n    virtual\n    override\n  {\n    if (VAULT_FEE() != uint256(0)) {\n      uint256 interestOwing = LIEN_TOKEN().getInterest(lienId);\n      uint256 x = (amount > interestOwing) ? interestOwing : amount;\n      uint256 fee = x.mulDivDown(VAULT_FEE(), 1000);\n      strategistUnclaimedShares += convertToShares(fee);\n    }\n  }\n```\n
MEDIUM severity: Vulnerable function: ```\nfunction testLiquidateSteal() external {\n        uint loanTokenAmount = 12000;\n        uint b. ```\nfunction testLiquidateSteal() external {\n        uint loanTokenAmount = 12000;\n        uint borrowAmount = 1000;\n        uint collateralAmountA = 10000;\n        uint collateralAmountB = 1400;\n        MockERC20 collateralToken = new MockERC20(collateralAmountA+collateralAmountB, 18);\n     

Vulnerable code:
```\nfunction testLiquidateSteal() external {\n        uint loanTokenAmount = 12000;\n        uint borrowAmount = 1000;\n        uint collateralAmountA = 10000;\n        uint collateralAmountB = 1400;\n        MockERC20 collateralToken = new MockERC20(collateralAmountA+collateralAmountB, 18);\n        MockERC20 loanToken = new MockERC20(loanTokenAmount, 18);\n        Pool pool = factory.deploySurgePool(IERC20(address(collateralToken)), IERC20(address(loanToken)), 0.8e18, 0.5e18, 1e15, 1e15, 0.1e18, 0.4e18, 0.6e18);\n        loanToken.approve(address(pool), loanTokenAmount);\n        pool.deposit(loanTokenAmount);\n\n        // Alice borrows 1000 \n        collateralToken.transfer(address(1), collateralAmountB);\n        vm.prank(address(1));\n        collateralToken.approve(address(pool), collateralAmountB);\n        vm.prank(address(1));\n        pool.addCollateral(address(1), collateralAmountB);\n        vm.prank(address(1));\n        pool.borrow(borrowAmount);\n\n        // Bob borrows 1000 too \n        collateralToken.approve(address(pool), collateralAmountA);\n        pool.addCollateral(address(this), collateralAmountA);\n        pool.borrow(borrowAmount);\n\n       // Bob's debt becomes 1200\n       vm.warp(block.timestamp + 365 days);\n       pool.withdraw(0);\n       uint mydebt = pool.getDebtOf(pool.debtSharesBalanceOf(address(this)), pool.debtSharesSupply(), pool.lastTotalDebt());\n       assertEq(mydebt, 1200);    \n\n      // Alice's debt becomes 1200\n       uint address1Debt = pool.getDebtOf(pool.debtSharesBalanceOf(address(1)), pool.debtSharesSupply(), pool.lastTotalDebt());\n       assertEq(address1Debt, 1200);  \n       assertEq(pool.lastTotalDebt(), 2399);  \n\n       uint myCollateralBeforeLiquidate = collateralToken.balanceOf(address(this));\n\n       // liquidate 200 for Alice\n       loanToken.approve(address(pool), 200);\n       for(int i; i<200; i++)\n            pool.liquidate(address(1), 1);\n\n      // Alice's debt shares are NOT reduced, now Bob's debt is reduced to 1100\n       uint debtShares = pool.debtSharesBalanceOf(address(1));\n       assertEq(debtShares, 1000);\n       assertEq(pool.lastTotalDebt(), 2199);\n       address1Debt = pool.getDebtOf(pool.debtSharesBalanceOf(address(1)), pool.debtSharesSupply(), pool.lastTotalDebt());\n       assertEq(address1Debt, 1100); \n       mydebt = pool.getDebtOf(pool.debtSharesBalanceOf(address(this)), pool.debtSharesSupply(), pool.lastTotalDebt());\n       assertEq(mydebt, 1100);    \n\n       // Bob gains the collateral as well proportionately \n       uint myCollateralAfterLiquidate = collateralToken.balanceOf(address(this));\n       assertEq(myCollateralAfterLiquidate-myCollateralBeforeLiquidate, 200);\n    }\n```\n