function _borrowLimit(_bathToken,_asset, 25e18, 23.32e18)
    // collateralFactor = 70% for cTokenStable
    await comptroller._setCollateralFactor(
      cTokenStable.address,
      parseUnits("0.7", 18)
    );
    // collateralFactor = 70% for cToken
    await comptroller._setCollateralFactor(
      cToken.address,
      parseUnits("0.7", 18)
    );
            if (_limit == 0) {
		// if collateral already provided
                if (_minted != 0) {
                    uint256 _max = _maxBorrow(_bathToken);

		    // take into account previous collateral
                    _loopBorrowed = wmul(_assetAmount, _collateralFactor).add(
                        _max
                    );

                } else {
                    _loopBorrowed = wmul(_assetAmount, _collateralFactor);
                    
                }
            } else {
                _loopBorrowed = wmul(_loopBorrowed, _collateralFactor);
                
            }
    // collateralFactor = 70% for cTokenStable
    await comptroller._setCollateralFactor(
      cTokenStable.address,
      parseUnits("0.7", 18)
    );
    // collateralFactor = 70% for cToken
    await comptroller._setCollateralFactor(
      cToken.address,
      parseUnits("0.5", 18)
    );
  function _borrowLimit(
        address _bathToken,
        address _asset,
        uint256 _assetAmount,
        uint256 _leverage
    ) internal view returns (uint256 _limit, uint256 _lastBorrow) {
        (, uint256 _collateralFactor, ) = comptroller.markets(_bathToken);
        // how much is needed to borrow in asset form
        uint256 _desiredAmount = wmul(_assetAmount, _leverage);
        console.log(_desiredAmount, "desiredAmount");

        // check if collateral was already supplied
        uint256 _minted = IERC20(_bathToken).balanceOf(address(this));
        
        // how much is borrowed on a current loop
        uint256 _loopBorrowed;
        
        while (_assetAmount <= _desiredAmount) {
            console.log("****** in loop");
            if (_limit == 0) {
		// if collateral already provided
                if (_minted != 0) {
                    uint256 _max = _maxBorrow(_bathToken);

                    console.log("max", _max);

		    // take into account previous collateral
                    _loopBorrowed = wmul(_assetAmount, _collateralFactor).add(
                        _max
                    );

                } else {
                    _loopBorrowed = wmul(_assetAmount, _collateralFactor);
                    
                }
            } else {
                _loopBorrowed = wmul(_loopBorrowed, _collateralFactor);
                
            }


            console.log("_loopBorrowed", _loopBorrowed);

            // here _assetAmount refers to the
            // TOTAL asset amount in the position
            _assetAmount += _loopBorrowed;
            console.log("_assetAmount", _assetAmount);

            if (_assetAmount > _desiredAmount) {
                // in case we've borrowed more than needed
                // return excess and calculate how much is
                // needed to borrow on the last loop
                // to not overflow _desiredAmount
                uint256 _borrowDelta = _desiredAmount.sub(
                    _assetAmount.sub(_loopBorrowed)
                );
                _lastBorrow = _borrowDelta.mul(WAD).div(_loopBorrowed);

                _limit++;
                break;
            } else if (_assetAmount == _desiredAmount) {
                // 1x short or perfect matching
                _limit++;
                break;
            } else {
                // default case
                _limit++;
            }

            console.log("limit", _limit);
        }
    }
uint256 maxIterations = 50;
uint256 currentIteration = 0;

while (_assetAmount <= _desiredAmount && currentIteration < maxIterations) {
    // existing logic
    currentIteration++;
}
uint256 minLoopBorrowed = 1e9; // Choose an appropriate minimum value based on the token decimals

while (_assetAmount <= _desiredAmount) {
    // existing logic

    if (_loopBorrowed < minLoopBorrowed) {
        break;
    }
}
function borrowLimit(uint256 _desiredAmount, uint256 _collateral, uint256 _loanFactor) public view returns (uint256) {
    // Calculate the borrowing limit using the closed-form solution
    uint256 borrowLimit = (_desiredAmount * _loanFactor) / (_collateral - _desiredAmount);

    return borrowLimit;
}
function _borrowLimit(
    address _bathToken,
    address _asset,
    uint256 _assetAmount,
    uint256 _leverage
) internal view returns (uint256 _limit, uint256 _lastBorrow) {
    (, uint256 _collateralFactor, ) = comptroller.markets(_bathToken);
    uint256 _desiredAmount = wmul(_assetAmount, _leverage);

    uint256 _minted = IERC20(_bathToken).balanceOf(address(this));

    if (_minted != 0) {
        uint256 _max = _maxBorrow(_bathToken);
        _assetAmount = wmul(_assetAmount, _collateralFactor).add(_max);
    }

    if (_collateralFactor == WAD) {
        // Collateral factor is 1, which means it's a 1x short or perfect matching
        _limit = (_desiredAmount.sub(_assetAmount)).div(WAD);
        _lastBorrow = wmul(_assetAmount, _collateralFactor);
    } else {
        // Calculate the number of terms using the closed-form formula for a geometric series
        _limit = uint256(
            log1p(
                wdiv(
                    (_desiredAmount.mul(WAD.sub(_collateralFactor))).sub(_assetAmount.mul(WAD)),
                    _assetAmount.mul(_collateralFactor)
                )
            ).div(log1p(_collateralFactor.sub(WAD)))
        );

        // Calculate the last borrow amount
        _lastBorrow = wmul(_assetAmount, pow(_collateralFactor, _limit)).sub(_assetAmount);
    }
}
