这个合约要在卖出的时候从滑点中扣除一部分兑换成USDT然后分给一些人，现在就在从滑点扣除后兑换成USDT这里出了问题。我在合约里将扣除的部分先转到合约里，然后查合约余额调用swapExactTokensForTokensSupportingFeeOnTransferTokens方法，报错PancakeLibrary: INSUFFICIENT_INPUT_AMOUNT，可是逻辑上应该是有值的，求大佬给看看问题出在哪里

contract TokenDistributor {
    constructor (address token) {
        //将代币全部授权给合约部署者，在这里是代币合约，让代币合约分配兑换到的代币资产
        IERC20(token).approve(msg.sender, uint(~uint256(0)));
    }
}

contract SAA is ERC20, Ownable {
    // 常量和状态变量优化：使用更紧凑的类型
    uint256 public lockPeriod; // 锁仓期
    uint256 private totalFee; // 滑点
    uint256 private baseFee; // 扣除滑点
    uint256 private referralFee; // 5%
    uint256 private buyFee; // 卖出手续费
    uint256[] private referralFees; // 推荐人手续费比例
    uint256[] private referralFeesNum; // 推荐人手续费达标人数

    TokenDistributor private _tokenDistributor; // 代币分发合约
    IInvite public inviteContract; // 推荐合约
    address public inviteContractAddress; // 推荐地址
    IPancakeRouter public pancakeRouter;
    IERC20 public immutable USDT;
    address public immutable pancakePair;
    address public feeReceiver;
    address public feeBuyer;
    address public tokenOwner;
    address public gainAddress;

    bool private inSwap;
    modifier lockTheSwap {
        require(!inSwap, "Already swapping");
        inSwap = true;
        _;
        inSwap = false;
    }

    // 合并相似的映射
    struct AccountInfo {
        uint256 acquireTime;
        bool isExcluded;
        bool isBlacklisted;
        bool isHolder;
        uint256 holderIndex;
    }
    mapping(address => AccountInfo) public accounts;
    address[] private holders;

    uint256 public maxTransactionAmount;
    uint256 public maxHoldingAmount;

    // 合并相似的事件
    event ConfigUpdated(string indexed param, uint256 value);
    event AddressUpdated(string indexed param, address addr);
    event TokenOperation(address indexed from, address indexed to, uint256 amount, string operation);

    constructor() ERC20('SAA', 'saa') {
        address _tokenOwner = 0x2bFB0C6c3c501092FE70420Cd6784F1832422c1B; // test
        address _pancakeRouter = 0xD99D1c33F9fC3444f8101754aBC46c52416550D1; // test
        address _usdt = 0x337610d27c682E347C9cD60BD4b3b107C9d34dDd; // test
        inviteContractAddress = 0x33b7415bebAEe63E1fe1E70ee85056AbC63aEc5b; // test
        address _feeReceiver = 0xEc9C8E1866761847E6d2e8398BA0dE5EBe4Da80d;
        address _feeBuyer = 0xEc9C8E1866761847E6d2e8398BA0dE5EBe4Da80d;
        address _gainAddress = 0x1d057F5489938Ba8477EC3d55DCe9ac0bc5482B0;

        inviteContract = IInvite(inviteContractAddress);
        pancakeRouter = IPancakeRouter(_pancakeRouter);
        USDT = IERC20(_usdt);
        feeReceiver = _feeReceiver;
        feeBuyer = _feeBuyer;
        tokenOwner = _tokenOwner;
        gainAddress = _gainAddress;
        _tokenDistributor = new TokenDistributor(_usdt);

        // 创建交易对
        pancakePair = IPancakeFactory(pancakeRouter.factory()).createPair(address(this), address(USDT));

        // 设置特权地址
        accounts[owner()].isExcluded = true;
        accounts[_tokenOwner].isExcluded = true;
        accounts[_feeReceiver].isExcluded = true;
        accounts[_feeBuyer].isExcluded = true;
        accounts[pancakePair].isExcluded = true;
        accounts[_pancakeRouter].isExcluded = true;
        accounts[address(this)].isExcluded = true;

        // 初始化代币和参数
        lockPeriod = 60 * 5;

        totalFee = 110;
        baseFee = 60;
        referralFee = 50;
        buyFee = 50;
        uint256 _totalSupply = 10000 * 10000 * 10 ** decimals();
        referralFees = [10, 10, 5, 5, 5, 5, 5, 5];
        referralFeesNum = [3, 6, 9, 12, 15, 18, 18, 18];
        maxTransactionAmount = _totalSupply * 5 / 100;
        maxHoldingAmount = _totalSupply * 10 / 100;

        _approve(address(this), address(pancakeRouter), type(uint256).max);
        USDT.approve(_pancakeRouter, type(uint256).max);

        _mint(_tokenOwner, _totalSupply);
    }

    function getTokenDistributor() external view returns (address) {
        return address(_tokenDistributor);
    }

    // 合并配置函数
    function updateConfig(string calldata param, uint256 value) external onlyOwner {
        if (keccak256(bytes(param)) == keccak256(bytes("lockPeriod"))) {
            require(value > 0, "Invalid lock period");
            lockPeriod = value;
        } else if (keccak256(bytes(param)) == keccak256(bytes("maxTransaction"))) {
            require(value > 0 && value <= maxHoldingAmount, "Invalid max transaction");
            maxTransactionAmount = value;
        } else if (keccak256(bytes(param)) == keccak256(bytes("maxHolding"))) {
            require(value >= maxTransactionAmount, "Invalid max holding");
            maxHoldingAmount = value;
        } else {
            revert("Invalid parameter");
        }
        emit ConfigUpdated(param, value);
    }

    // 合并地址更新函数
    function updateAddress(string calldata param, address addr) external onlyOwner {
        require(addr != address(0), "Invalid address");

        if (keccak256(bytes(param)) == keccak256(bytes("feeReceiver"))) {
            feeReceiver = addr;
        } else if (keccak256(bytes(param)) == keccak256(bytes("feeBuyer"))) {
            feeBuyer = addr;
        } else if (keccak256(bytes(param)) == keccak256(bytes("gainAddress"))) {
            gainAddress = addr;
        } else if (keccak256(bytes(param)) == keccak256(bytes("blacklist"))) {
            require(addr != owner() && addr != tokenOwner, "Protected address");
            accounts[addr].isBlacklisted = !accounts[addr].isBlacklisted;
        } else if (keccak256(bytes(param)) == keccak256(bytes("excludeFee"))) {
            accounts[addr].isExcluded = !accounts[addr].isExcluded;
        } else {
            revert("Invalid parameter");
        }
        emit AddressUpdated(param, addr);
    }

    function _updateHolders(address account) private {
        uint256 balance = balanceOf(account);
        AccountInfo storage info = accounts[account];

        if (balance > 0 && !info.isHolder) {
            holders.push(account);
            info.holderIndex = holders.length - 1;
            info.isHolder = true;
            emit TokenOperation(address(0), account, 0, "holder_added");
        } else if (balance == 0 && info.isHolder) {
            uint256 index = info.holderIndex;
            uint256 lastIndex = holders.length - 1;

            if (index != lastIndex) {
                address lastHolder = holders[lastIndex];
                holders[index] = lastHolder;
                accounts[lastHolder].holderIndex = uint16(index);
            }

            holders.pop();
            info.isHolder = false;
            emit TokenOperation(account, address(0), 0, "holder_removed");
        }
    }

    // 更换inviteContract
    function setInviteContract(address newInviteContract) external onlyOwner {
        require(newInviteContract != address(0), "Invalid invite contract");
        require(newInviteContract != inviteContractAddress, "Invalid invite contract");
        inviteContractAddress = newInviteContract;
        inviteContract = IInvite(inviteContractAddress);
    }

    // 修改referralFees
    function setReferralFees(uint256 _totalFee, uint256[] memory _referralFees, uint256[] memory _referralFeesNum) external onlyOwner {
        require(_totalFee >= 0 && _totalFee <= 1000, "Invalid total fee");
        uint256 _REFERRAL_FEE = 0;
        for (uint256 i = 0; i < _referralFees.length; i++) {
            require(_referralFees[i] >= 0 && _referralFees[i] <= 100, "Invalid referral fee");
            _REFERRAL_FEE += _referralFees[i];
        }
        require(_REFERRAL_FEE >= 1000, "Invalid referral fee");
        totalFee = _totalFee;
        referralFee = _REFERRAL_FEE;
        baseFee = _totalFee - _REFERRAL_FEE;
        referralFees = _referralFees;
        referralFeesNum = _referralFeesNum;
    }
    // 查看TOTAL_FEE, REFERRAL_FEE, BASE_FEE, referralFees
    function getReferralFees() external view returns (uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
        return (totalFee, referralFee, baseFee, referralFees, referralFeesNum);
    }

    // 获取用户信息
    function getAccountInfo(address account) external view returns (bool isHolder, uint256 balance, uint256 acquireTime, bool isBlacklisted, bool isExcluded) {
        AccountInfo storage info = accounts[account];
        return (info.isHolder, balanceOf(account), info.acquireTime, info.isBlacklisted, info.isExcluded);
    }

    // 设置指定用户的排除属性
    function setExcluded(address account, bool isExcluded) external onlyOwner {
        require(account != address(0), "Invalid account");
        accounts[account].isExcluded = isExcluded;
    }

    // 设置指定用户的黑名单属性
    function setBlacklisted(address account, bool isBlacklisted) external onlyOwner {
        require(account != address(0), "Invalid account");
        accounts[account].isBlacklisted = isBlacklisted;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        require(from != address(0) && to != address(0) && amount > 0, "Invalid transfer");
        require(!accounts[from].isBlacklisted && !accounts[to].isBlacklisted, "Blacklisted");

        if (inSwap) {
            super._transfer(from, to, amount);
            return;
        }

        bool isSelling = to == pancakePair;
        bool isBuying = from == pancakePair;
        AccountInfo storage fromInfo = accounts[from];
        AccountInfo storage toInfo = accounts[to];
        AccountInfo storage originInfo = accounts[tx.origin];
        if(isBuying) {
            require(toInfo.isExcluded || originInfo.isExcluded, "cant buy");
            uint256 feeNum = (amount * buyFee) / 1000;
            amount -= feeNum;
            super._transfer(from, feeBuyer, feeNum);
            super._transfer(from, to, amount);
            return;
        }

        if (isSelling) {
            if (fromInfo.isExcluded) {
                super._transfer(from, to, amount);
            } else {
            //     require(block.timestamp >= fromInfo.acquireTime + lockPeriod, "Locked");

                uint256 totalNum = (amount * totalFee) / 1000;
                uint256 baseNum = (amount * baseFee) / 1000;
                uint256 referralNum = totalNum - baseNum;

                super._transfer(from, feeReceiver, baseNum);
                super._transfer(from, address(this), referralNum);
                amount -= totalNum;
                super._transfer(from, to, amount);
                _distributeFees();

                _updateHolders(from);
            }
            return;
        }

        if (!isBuying && !isSelling) {
            require(fromInfo.isExcluded, "Transfer not allowed: sender not excluded");
            super._transfer(from, to, amount);
            if (accounts[to].acquireTime == 0) {
                accounts[to].acquireTime = block.timestamp;
            }
            _updateHolders(to);
        }
    }

    function _distributeFees() private lockTheSwap {
        uint256 totalNum = balanceOf(address(this));
        require(totalNum > 0, "No fees to distribute");
        // 设置兑换路径
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = address(USDT);

        // 执行兑换，使用更长的截止时间
        pancakeRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            totalNum,
            0, // 接受任何数量的USDT
            path,
            address(_tokenDistributor),
            block.timestamp + 300 // 5分钟的缓冲时间
        );

        // 兑换成功，继续处理
        uint256 receivedUsdt = USDT.balanceOf(address(_tokenDistributor));

        // 计算referralFees总和
        uint256 totalReferralFees = 0;
        for (uint256 i = 0; i < referralFees.length; i++) {
            totalReferralFees += referralFees[i];
        }

        // 按比例分配USDT
        address current = tx.origin;
        uint256 remainingUsdt = receivedUsdt;

        for (uint256 i = 0; i < referralFees.length && remainingUsdt > 0; i++) {
            current = inviteContract.getReferrer(current);
            if (current == address(0)) break;

            uint256 referralCount = inviteContract.getReferralCount(current);
            if (referralCount >= referralFeesNum[i]) {
                // 按照referralFees[i]在totalReferralFees中的比例计算USDT数量
                uint256 usdtShare = (receivedUsdt * referralFees[i]) / totalReferralFees;
                if (usdtShare > remainingUsdt) usdtShare = remainingUsdt;

                if (usdtShare > 0) {
                    require(USDT.transferFrom(address(_tokenDistributor), current, usdtShare), "USDT transfer failed");
                    remainingUsdt -= usdtShare;
                }
            }
        }

        // 将剩余的USDT发送给gainAddress
        if (remainingUsdt > 0) {
            require(USDT.transferFrom(address(_tokenDistributor), gainAddress, remainingUsdt), "USDT transfer failed");
        }
    }

    // 必要的公共查询函数
    function getTokenHolders() external view returns (address[] memory) {
        address[] memory result = new address[](holders.length);
        uint256 count = 0;

        for (uint256 i = 0; i < holders.length; i++) {
            address holder = holders[i];
            if (holder != tokenOwner && holder != pancakePair && holder != feeReceiver && balanceOf(holder) > 0) {
                result[count++] = holder;
            }
        }

        assembly {
            mstore(result, count)
        }
        return result;
    }

    // 减少指定账户代币10%
    function reduceAccountBalance(address account, uint256 percent) external onlyOwner {
        require(account != address(0), "Invalid address");
        require(percent > 0 && percent <= 1000, "Invalid percent");

        uint256 currentBalance = balanceOf(account);
        require(currentBalance > 0, "Account has no balance");

        // 计算要减少的金额
        uint256 amountToReduce = (currentBalance * percent) / 1000;
        require(amountToReduce > 0, "Amount to reduce is too small");

        // 从账户中销毁代币
        _burn(account, amountToReduce);

        // 更新持有者列表
        _updateHolders(account);
    }

    // 减少币对中代币数量使价格提高percent/1000
    function increasePriceByTenPercent(uint256 percent) external onlyOwner {
        require(percent > 0 && percent <= 1000, "Invalid percent");
        // 获取币对中的储备量
        (uint112 reserve0, uint112 reserve1, ) = IPancakePair(pancakePair).getReserves();

        // 确定我们的代币是token0还是token1
        address token0 = IPancakePair(pancakePair).token0();
        uint112 ourReserve = address(this) == token0 ? reserve0 : reserve1;

        // 为了提高价格percent/1000
        uint256 amountToReduce = uint256(ourReserve) - uint256(ourReserve) * 1000 / (1000 + percent);
        require(amountToReduce > 0, "Amount to reduce is too small");

        // 从币对中移除代币并销毁
        // 注意：这里我们直接从币对地址销毁代币，这会减少流动性池中的代币数量
        _burn(pancakePair, amountToReduce);
    }
}