SafeMath96.sol

pragma solidity ^0.5.17;
pragma experimental ABIEncoderV2;

/**
 * @title SafeMath96 contract.
 * @notice Improved Solidity's arithmetic operations with added overflow checks.
 * @dev SafeMath96 uses uint96, unsigned integers of 96 bits length, so every
 * integer from 0 to 2^96-1 can be operated.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * SafeMath restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this contract instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 * */
contract SafeMath96 {
    function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2 ** 32, errorMessage);
        return uint32(n);
    }

    function safe64(uint256 n, string memory errorMessage) internal pure returns (uint64) {
        require(n < 2 ** 64, errorMessage);
        return uint64(n);
    }

    function safe96(uint256 n, string memory errorMessage) internal pure returns (uint96) {
        require(n < 2 ** 96, errorMessage);
        return uint96(n);
    }

    /**
     * @notice Adds two unsigned integers, reverting on overflow.
     * @dev Counterpart to Solidity's `+` operator.
     * @param a First integer.
     * @param b Second integer.
     * @param errorMessage The revert message on overflow.
     * @return The safe addition a+b.
     * */
    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        uint96 c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    /**
     * @notice Substracts two unsigned integers, reverting on underflow.
     * @dev Counterpart to Solidity's `-` operator.
     * @param a First integer.
     * @param b Second integer.
     * @param errorMessage The revert message on underflow.
     * @return The safe substraction a-b.
     * */
    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @notice Multiplies two unsigned integers, reverting on overflow.
     * @dev Counterpart to Solidity's `*` operator.
     * @param a First integer.
     * @param b Second integer.
     * @param errorMessage The revert message on overflow.
     * @return The safe product a*b.
     * */
    function mul96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        if (a == 0) {
            return 0;
        }

        uint96 c = a * b;
        require(c / a == b, errorMessage);

        return c;
    }

    /**
     * @notice Divides two unsigned integers, reverting on overflow.
     * @dev Counterpart to Solidity's `/` operator.
     * @param a First integer.
     * @param b Second integer.
     * @param errorMessage The revert message on overflow.
     * @return The safe division a/b.
     * */
    function div96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint96 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }
}