library SafeMathInt {
        int256 private constant MIN_INT256 = int256(1) << 255;
        int256 private constant MAX_INT256 = ~(int256(1) << 255);
    
        /**
         * @dev Multiplies two int256 variables and fails on overflow.
         */
        function mul(int256 a, int256 b)
            internal
            pure
            returns (int256)
        {
            int256 c = a * b;
    
            // Detect overflow when multiplying MIN_INT256 with -1
            require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
            require((b == 0) || (c / b == a));
            return c;
        }
    
        /**
         * @dev Division of two int256 variables and fails on overflow.
         */
        function div(int256 a, int256 b)
            internal
            pure
            returns (int256)
        {
            // Prevent overflow when dividing MIN_INT256 by -1
            require(b != -1 || a != MIN_INT256);
    
            // Solidity already throws when dividing by 0.
            return a / b;
        }
    
        /**
         * @dev Subtracts two int256 variables and fails on overflow.
         */
        function sub(int256 a, int256 b)
            internal
            pure
            returns (int256)
        {
            int256 c = a - b;
            require((b >= 0 && c <= a) || (b < 0 && c > a));
            return c;
        }
    
        /**
         * @dev Adds two int256 variables and fails on overflow.
         */
        function add(int256 a, int256 b)
            internal
            pure
            returns (int256)
        {
            int256 c = a + b;
            require((b >= 0 && c >= a) || (b < 0 && c < a));
            return c;
        }
    
        /**
         * @dev Converts to absolute value, and fails on overflow.
         */
        function abs(int256 a)
            internal
            pure
            returns (int256)
        {
            require(a != MIN_INT256);
            return a < 0 ? -a : a;
        }
    }
/**
 * @title SafeMathInt
 * @dev Math operations for int256 with overflow safety checks.
 */
function sub(int256 a, int256 b)
    internal
    pure
    returns (int256)
{
    int256 c = a - b;
    require((b >= 0 && c <= a) || (b < 0 && c > a));
    return c;
}

/**
 * @dev Subtracts two int256 variables and fails on overflow.
 */