REVERT opcode executed. Message: SafeMath: subtraction overflow

Question

When I trigger buyMembership function from shasta.tronscan.io I am getting this error. library SafeMath was working fine lately. But I do not know why it is giving me this error. Please help me sort this thing I have already wasted a complete day on this.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

This is ITRC20 interface

interface ITRC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

SafeMath library I used.

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

This is my contract. buyMembership function with correct params generates this error of

REVERT opcode executed. Message: SafeMath: subtraction overflow

contract TEST101 {
    ITRC20 USDT;
    address payable public owner;
    address payable public ma;
    address payable public fw;

    struct User {
        uint256 commission_balance;
        uint256 member_id;
        uint40 membership_time;
        uint256 order_history;
    }

    struct History {
        uint256 order_amount;
        uint40 order_time;
    }

    struct Admin {
        uint256 active;
    }

    mapping(uint256 => User) public users;
    mapping(address => Admin) public admins;
    mapping(uint256 => mapping(uint256 => History)) public histories;

    event BuymemberShip(address user_wallet, uint256 member_id, uint256 amount, uint40 time);
    event BuyProduct(address user_wallet, uint256 member_id, uint256 amount, uint40 time);
    event Withdraw(address user_wallet, uint256 member_id, uint256 amount, uint40 time);
    event UpdateBalance(address user_wallet, uint256 member_id, uint256 amount, uint40 time);

    constructor(address payable _ma, ITRC20 _usdt, address payable _fw)  {
        ma = _ma;
        owner = payable(msg.sender);
        USDT = _usdt;
        fw = _fw;
    }

    function buyMembership(uint256 _mid, uint256 _amount, uint256 _charges) external {
        USDT.transferFrom(msg.sender, address(this), _amount);
        users[_mid].membership_time = uint40(block.timestamp);
        users[_mid].order_history = 0;
        users[_mid].member_id = _mid;
        USDT.transfer(fw, _charges);
        emit BuymemberShip(msg.sender, _mid, _amount, uint40(block.timestamp));
    }

    function purchase(uint256 _mid, uint256 _amount) external {
        USDT.transferFrom(msg.sender, address(this), _amount);
        users[_mid].order_history += 1;
        histories[_mid][users[_mid].order_history].order_amount = _amount;
        histories[_mid][users[_mid].order_history].order_time = uint40(block.timestamp);
        emit BuyProduct(msg.sender, _mid, _amount, uint40(block.timestamp));
    }

    function withdraw(address addr, uint256 _mid, uint256 _amount) external {
        if (admins[msg.sender].active == 1 || msg.sender == ma) {
            if (users[_mid].commission_balance >= _amount) {
                users[_mid].commission_balance -= _amount;
                USDT.transfer(msg.sender, _amount);
                emit Withdraw(msg.sender, _mid, _amount, uint40(block.timestamp));
            } else {
                revert("not enough balance");
            }
        } else {
            revert("permission denied");
        }
    }
}