F:/My Projects/LSEngine/Modules/LSStandardLib/Src/LargeInteger/LSSTD128BitInteger.h

#ifndef __LSE_128BITINTEGER_H__
#define __LSE_128BITINTEGER_H__

#include "../LSSTDStandardLib.h"

namespace lsstd {

        class C128BitInteger {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                            C128BitInteger() {}
                LSE_CALLCTOR                                                            C128BitInteger( const C128BitInteger &_biOp ) {
                        m_ui32Digits[0] = _biOp.m_ui32Digits[0];
                        m_ui32Digits[1] = _biOp.m_ui32Digits[1];
                        m_ui32Digits[2] = _biOp.m_ui32Digits[2];
                        m_ui32Digits[3] = _biOp.m_ui32Digits[3];
                }
                LSE_CALLCTOR                                                            C128BitInteger( LSINT64 _i64Src ) {
                        m_ui32Digits[0] = static_cast<LSUINT32>(_i64Src & 0xFFFFFFFFULL);
                        m_ui32Digits[1] = static_cast<LSUINT32>(_i64Src >> 32ULL);
                        _i64Src = (_i64Src >> 63);

                        m_ui32Digits[2] = m_ui32Digits[3] = static_cast<LSUINT32>(_i64Src);
                }
                LSE_CALLCTOR                                                            C128BitInteger( LSUINT64 _ui64Src ) {
                        m_ui32Digits[0] = static_cast<LSUINT32>(_ui64Src & 0xFFFFFFFFULL);
                        m_ui32Digits[1] = static_cast<LSUINT32>(_ui64Src >> 32ULL);
                        m_ui32Digits[2] = m_ui32Digits[3] = 0UL;
                }
                LSE_CALLCTOR                                                            C128BitInteger( const LSUINT32 * _pui32Src ) {
                        LSUINT32 ui32Len = 4UL;
                        while ( ui32Len && !_pui32Src[--ui32Len] ) {}
                        ++ui32Len;
                        LSUINT32 I, J = ui32Len - 1UL;
                        for ( I = 0UL; I < ui32Len; ++I, --J ) {
                                m_ui32Digits[I] = _pui32Src[J];
                        }
                        for ( ; I < 4UL; ++I ) {
                                m_ui32Digits[I] = 0UL;
                        }
                }


                // == Operators.
                C128BitInteger LSE_CALL                                         operator - () const {
                        C128BitInteger biReturn;
                        Negate( (*this), biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator + ( const C128BitInteger &_biOp ) const {
                        C128BitInteger biReturn;
                        Add( (*this), _biOp, biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator * ( const C128BitInteger &_biOp ) const {
                        C128BitInteger biReturn;
                        Multiply( (*this), _biOp, biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator *= ( const C128BitInteger &_biOp ) {
                        C128BitInteger biReturn;
                        Multiply( (*this), _biOp, biReturn );
                        (*this) = biReturn;

                        return (*this);
                }

                C128BitInteger LSE_CALL                                         operator / ( const C128BitInteger &_biOp ) const {
                        C128BitInteger biReturn;
                        Divide( (*this), _biOp, biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator /= ( const C128BitInteger &_biOp ) {
                        C128BitInteger biReturn;
                        Divide( (*this), _biOp, biReturn );
                        (*this) = biReturn;

                        return (*this);
                }

                C128BitInteger LSE_CALL                                         operator % ( const C128BitInteger &_biOp ) const {
                        C128BitInteger biReturn;
                        Modulus( (*this), _biOp, biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator - ( const C128BitInteger &_biOp ) const {
                        C128BitInteger biReturn;
                        Subtract( (*this), _biOp, biReturn );

                        return biReturn;
                }

                C128BitInteger LSE_CALL                                         operator << ( LSUINT32 _ui32Shift ) const {
                        C128BitInteger biReturn( (*this) );
                        ShiftLeft( biReturn.m_ui32Digits, 4UL, _ui32Shift );

                        return biReturn;
                }

                C128BitInteger & LSE_CALL               operator <<= ( LSUINT32 _ui32Shift ) {
                        ShiftLeft( m_ui32Digits, 4UL, _ui32Shift );

                        return (*this);
                }

                C128BitInteger LSE_CALL                                         operator >> ( LSUINT32 _ui32Shift ) const {
                        C128BitInteger biReturn( (*this) );
                        ShiftRight( biReturn.m_ui32Digits, 4UL, _ui32Shift );

                        // Fix sign bits on negative numbers.
                        if ( m_ui32Digits[4UL-1UL] & 0x80000000UL ) {
                                for ( LSUINT32 I = 4UL - 1UL; I >= 4UL; --I ) {
                                        biReturn.m_ui32Digits[I] = 0xFFFFFFFF;
                                }

                                LSUINT32 ui32Mask = 0x80000000UL;
                                for ( LSUINT32 I = 0UL; I < 32UL; ++I ) {
                                        if ( biReturn.m_ui32Digits[4UL-1] & ui32Mask ) {
                                                break;
                                        }
                                        biReturn.m_ui32Digits[4UL-1] |= ui32Mask;
                                        ui32Mask >>= 1UL;
                                }
                        }

                        return biReturn;
                }

                C128BitInteger & LSE_CALL               operator >>= ( LSUINT32 _ui32Shift ) {
                        LSUINT32 ui32Used = ShiftRight( m_ui32Digits, 4UL, _ui32Shift );
                        ui32Used = CStd::Max<LSUINT32>( ui32Used, 1UL );

                        // Fix sign bits on negative numbers.
                        if ( m_ui32Digits[4UL-1UL] & 0x80000000UL ) {
                                for ( LSUINT32 I = 4UL - 1UL; I >= ui32Used; --I ) {
                                        m_ui32Digits[I] = 0xFFFFFFFF;
                                }

                                LSUINT32 ui32Mask = 0x80000000UL;
                                for ( LSUINT32 I = 0UL; I < 32UL; ++I ) {
                                        if ( m_ui32Digits[ui32Used-1] & ui32Mask ) {
                                                break;
                                        }
                                        m_ui32Digits[ui32Used-1] |= ui32Mask;
                                        ui32Mask >>= 1UL;
                                }
                                ui32Used = 4UL;
                        }

                        return (*this);
                }

                bool LSE_CALL                                                           operator > ( const C128BitInteger &_biOp ) const {
                        LSINT32 i32Pos = 4UL - 1;

                        if ( (m_ui32Digits[i32Pos] & 0x80000000UL) && !(_biOp.m_ui32Digits[i32Pos] & 0x80000000UL) ) {
                                return false;
                        }
                        if ( !(m_ui32Digits[i32Pos] & 0x80000000UL) && (_biOp.m_ui32Digits[i32Pos] & 0x80000000UL) ) {
                                return true;
                        }

                        // Skip past all digits that are the same.
                        for ( i32Pos = 4UL; i32Pos >= 0 && m_ui32Digits[i32Pos] == _biOp.m_ui32Digits[i32Pos]; --i32Pos ) {}

                        // If we found a different digit.
                        if ( i32Pos >= 0 ) {
                                return m_ui32Digits[i32Pos] > _biOp.m_ui32Digits[i32Pos];
                        }

                        // They are the same.
                        return false;
                }

                bool LSE_CALL                                                           operator < ( const C128BitInteger &_biOp ) const {
                        LSINT32 i32Pos = 4UL - 1;

                        if ( (m_ui32Digits[i32Pos] & 0x80000000UL) && !(_biOp.m_ui32Digits[i32Pos] & 0x80000000UL) ) {
                                return true;
                        }
                        if ( !(m_ui32Digits[i32Pos] & 0x80000000UL) && (_biOp.m_ui32Digits[i32Pos] & 0x80000000UL) ) {
                                return false;
                        }

                        // Skip past all digits that are the same.
                        for ( i32Pos = 3; i32Pos >= 0 && m_ui32Digits[i32Pos] == _biOp.m_ui32Digits[i32Pos]; --i32Pos ) {}

                        // If we found a different digit.
                        if ( i32Pos >= 0 ) {
                                return m_ui32Digits[i32Pos] < _biOp.m_ui32Digits[i32Pos];
                        }

                        // They are the same.
                        return false;
                }


                // == Functions.
                static LSVOID LSE_CALL                                          Negate( const C128BitInteger &_biValue,
                        C128BitInteger &_biResult ) {
                        // Handle negation of 0 manually.
                        if ( _biValue.m_ui32Digits[0] == 0ULL && _biValue.m_ui32Digits[1] == 0ULL &&
                                _biValue.m_ui32Digits[2] == 0ULL && _biValue.m_ui32Digits[3] == 0ULL ) {
                                _biResult.m_ui32Digits[0] = _biResult.m_ui32Digits[1] = _biResult.m_ui32Digits[2] = _biResult.m_ui32Digits[3] = 0ULL;
                                return;
                        }

                        // Perform 1's compliment.
                        for ( LSINT32 I = 4UL; --I >= 0; ) {
                                _biResult.m_ui32Digits[I] = ~_biValue.m_ui32Digits[I];
                        }

                        // Add 1 to the result.
                        LSUINT64 ui64Value, ui64Carry = 1UL;
                        for ( LSUINT32 I = 0; ui64Carry && I < 4UL; ++I ) {
                                ui64Value = _biResult.m_ui32Digits[I] + 1UL;
                                _biResult.m_ui32Digits[I] = static_cast<LSUINT32>(ui64Value & 0xFFFFFFFFULL);
                                ui64Carry = ui64Value >> 32UL;
                        }
                }

                static LSUINT32 LSE_CALL                                        ShiftLeft( LSUINT32 * _pui32Data, LSUINT32 _ui32Len,
                        LSUINT32 _ui32Amount ) {

                        LSUINT32 ui32ShiftAmt = 32UL;
                        LSUINT32 ui32Used = _ui32Len;

                        while ( ui32Used > 1UL && _pui32Data[ui32Used-1] == 0 ) {
                                --ui32Used;
                        }


                        for ( LSUINT32 I = _ui32Amount; I > 0UL; ) {
                                if ( I < ui32ShiftAmt ) {
                                        ui32ShiftAmt = I;
                                }

                                LSUINT64 ui64Carry = 0ULL;

                                for ( LSUINT32 J = 0UL; J < ui32Used; ++J ) {
                                        LSUINT64 ui64Value = static_cast<LSUINT64>(_pui32Data[J]) << ui32ShiftAmt;
                                        ui64Value |= ui64Carry;

                                        _pui32Data[J] = static_cast<LSUINT32>(ui64Value);
                                        ui64Carry = ui64Value >> 32ULL;
                                }

                                if ( ui64Carry ) {
                                        if ( ui32Used + 1UL <= _ui32Len ) {
                                                _pui32Data[ui32Used++] = static_cast<LSUINT32>(ui64Carry);
                                        }
                                }

                                I -= ui32ShiftAmt;
                        }
                        return ui32Used;
                }

                static LSUINT32 LSE_CALL                                        ShiftRight( LSUINT32 * _pui32Data, LSUINT32 _ui32Len,
                        LSUINT32 _ui32Amount ) {

                        LSUINT32 ui32ShiftAmt = 32ULL;
                        LSUINT32 ui32InvShift = 0UL;
                        LSUINT32 ui32Used = _ui32Len;

                        while ( ui32Used > 1UL && _pui32Data[ui32Used-1] == 0 ) {
                                --ui32Used;
                        }


                        for ( LSUINT32 I = _ui32Amount; I > 0UL; ) {
                                if ( I < ui32ShiftAmt ) {
                                        ui32ShiftAmt = I;
                                        ui32InvShift = 32ULL - ui32ShiftAmt;
                                }

                                LSUINT64 ui64Carry = 0ULL;

                                for ( LSINT32 J = static_cast<LSINT32>(ui32Used - 1UL); J >= 0; --J ) {
                                        LSUINT64 ui64Value = static_cast<LSUINT64>(_pui32Data[J]) >> static_cast<LSUINT64>(ui32ShiftAmt);
                                        ui64Value |= ui64Carry;

                                        ui64Carry = _pui32Data[J] << ui32InvShift;
                                        _pui32Data[J] = static_cast<LSUINT32>(ui64Value);
                                }

                                I -= ui32ShiftAmt;
                        }

                        // Remove opening 0's.
                        while ( ui32Used > 1UL && _pui32Data[ui32Used-1UL] == 0 ) {
                                --ui32Used;
                        }

                        return ui32Used;
                }

                static LSVOID LSE_CALL                                          Add( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biResult ) {

                        LSUINT64 ui64Carry = 0ULL;
                        for ( LSUINT32 I = 0UL; I < 4UL; ++I ) {
                                LSUINT64 ui64Sum = static_cast<LSUINT64>(_biLeft.m_ui32Digits[I]) + static_cast<LSUINT64>(_biRight.m_ui32Digits[I]) + ui64Carry;
                                ui64Carry = ui64Sum >> 32ULL;
                                _biResult.m_ui32Digits[I] = static_cast<LSUINT32>(ui64Sum & 0xFFFFFFFFULL);
                        }
                        // Carries are simply lost.  This class behaves like a real 128-bit integer would.
                }

                static LSVOID LSE_CALL                                          Subtract( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biResult ) {
                        LSUINT32 ui32LeftUsed = 4UL;
                        while ( ui32LeftUsed && !_biLeft.m_ui32Digits[--ui32LeftUsed] ) {}
                        ++ui32LeftUsed;
                        LSUINT32 ui32RightUsed = 4UL;
                        while ( ui32RightUsed && !_biRight.m_ui32Digits[--ui32RightUsed] ) {}
                        ++ui32RightUsed;
                        LSUINT32 ui32Total = CStd::Max( ui32LeftUsed, ui32RightUsed );

                        LSINT64 i64Carry = 0;
                        LSUINT32 I;
                        for ( I = 0UL; I < ui32Total; ++I ) {
                                LSINT64 i64Dif = static_cast<LSINT64>(_biLeft.m_ui32Digits[I]) - static_cast<LSINT64>(_biRight.m_ui32Digits[I]) - i64Carry;
                                _biResult.m_ui32Digits[I] = static_cast<LSUINT32>(i64Dif & 0xFFFFFFFF);

                                if ( i64Dif < 0LL ) {
                                        i64Carry = 1LL;
                                }
                                else {
                                        i64Carry = 0LL;
                                }
                        }

                        if ( i64Carry ) {
                                for ( ; I < 4UL; ++I ) {
                                        _biResult.m_ui32Digits[I] = 0xFFFFFFFFUL;
                                }
                        }
                        else {
                                for ( ; I < 4UL; ++I ) {
                                        _biResult.m_ui32Digits[I] = 0UL;
                                }
                        }
                }

                static LSVOID LSE_CALL                                          Multiply( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biResult ) {
                        const LSUINT32 ui32LastPos = 4UL - 1UL;

                        // We work on positive values only, then negate at the end.
                        LSBOOL bLeftNeg = false, bRightNeg = false;

                        C128BitInteger biLeftAbs( _biLeft );
                        C128BitInteger biRightAbs( _biRight );

                        if ( _biLeft.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                bLeftNeg = true;
                                biLeftAbs = -_biLeft;
                        }
                        if ( _biRight.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                bRightNeg = true;
                                biRightAbs = -_biRight;
                        }

                        // Clear the return.
                        _biResult = C128BitInteger( 0ULL );


                        // Multiply.
                        for ( LSUINT32 I = 0UL; I < 4UL; ++I ) {
                                if ( biLeftAbs.m_ui32Digits[I] == 0 ) { continue; }
                                LSUINT64 ui64Carry = 0ULL;
                                for ( LSUINT32 J = 0UL, K = I; J < 4UL; ++J, ++K ) {
                                        LSUINT64 ui64Value = static_cast<LSUINT64>(biLeftAbs.m_ui32Digits[I]) * static_cast<LSUINT64>(biRightAbs.m_ui32Digits[J]) +
                                                static_cast<LSUINT64>(_biResult.m_ui32Digits[K]) + ui64Carry;

                                        _biResult.m_ui32Digits[K] = static_cast<LSUINT32>(ui64Value & 0xFFFFFFFF);

                                        ui64Carry = ui64Value >> 32UL;
                                }
                                if ( ui64Carry ) {
                                        _biResult.m_ui32Digits[I+4UL] = static_cast<LSUINT32>(ui64Carry);
                                }
                        }

                        // Reverse the signs if necessary.
                        if ( bLeftNeg != bRightNeg ) {
                                Negate( _biResult, _biResult );
                        }
                }

                static LSVOID LSE_CALL                                          Divide( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biResult ) {
                        if ( !_biRight.m_ui32Digits[0] && !_biRight.m_ui32Digits[1] && !_biRight.m_ui32Digits[2] && !_biRight.m_ui32Digits[3] ) {
                                _biResult = C128BitInteger( 0ULL );
                                return;
                        }
                        const LSUINT32 ui32LastPos = 4UL - 1UL;

                        

                        C128BitInteger biNewLeft( _biLeft );
                        C128BitInteger biNewRight( _biRight );
                        
                        LSBOOL bDivisorNeg = false, bDividendNeg = false;
                        if ( _biLeft.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                bDividendNeg = true;
                                biNewLeft = -biNewLeft;
                        }
                        if ( _biRight.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                bDivisorNeg = true;
                                biNewRight = -biNewRight;
                        }

                        if ( biNewLeft < biNewRight ) {
                                _biResult = C128BitInteger( 0ULL );
                                return;
                        }

                        // Get the highest used value.
                        LSUINT32 ui32Used = 4UL;
                        while ( ui32Used && !biNewRight.m_ui32Digits[--ui32Used] ) {}
                        ++ui32Used;

                        // Hold the results.
                        C128BitInteger biRem;
                        if ( ui32Used == 1UL ) {
                                DivideS( biNewLeft, biNewRight,
                                        _biResult, biRem );
                        }
                        else {
                                DivideM( biNewLeft, biNewRight,
                                        _biResult, biRem );
                        }

                        if ( bDivisorNeg != bDividendNeg ) {
                                // Flip the sign.
                                _biResult = -_biResult;
                        }
                }

                static LSVOID LSE_CALL                                          Modulus( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biResult ) {
                        if ( !_biRight.m_ui32Digits[0] && !_biRight.m_ui32Digits[1] && !_biRight.m_ui32Digits[2] && !_biRight.m_ui32Digits[3] ) {
                                _biResult = C128BitInteger( 0ULL );
                                return;
                        }
                        const LSUINT32 ui32LastPos = 4UL - 1UL;

                        

                        C128BitInteger biNewLeft( _biLeft );
                        C128BitInteger biNewRight( _biRight );
                        
                        LSBOOL bDividendNeg = false;
                        if ( _biLeft.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                bDividendNeg = true;
                                biNewLeft = -biNewLeft;
                        }
                        if ( _biRight.m_ui32Digits[ui32LastPos] & 0x80000000UL ) {
                                biNewRight = -biNewRight;
                        }

                        if ( biNewLeft < biNewRight ) {
                                _biResult = _biLeft;
                                return;
                        }

                        // Hold the results.
                        // Get the highest used value.
                        LSUINT32 ui32Used = 4UL;
                        while ( ui32Used && !biNewRight.m_ui32Digits[--ui32Used] ) {}
                        ++ui32Used;

                        C128BitInteger biRes;
                        if ( ui32Used == 1UL ) {
                                DivideS( biNewLeft, biNewRight,
                                        biRes, _biResult );
                        }
                        else {
                                DivideM( biNewLeft, biNewRight,
                                        biRes, _biResult );
                        }

                        if ( bDividendNeg ) {
                                // Flip the sign.
                                _biResult = -_biResult;
                        }
                }


        protected :
                // == Members.
                LSUINT32                                                                        m_ui32Digits[4];


                // == Functions.
                static LSVOID LSE_CALL                                          DivideM( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biQuotient,
                        C128BitInteger &_biRemainder ) {

                        C128BitInteger biResult = C128BitInteger( 0ULL );
                        LSUINT32 ui32Remainder[4UL+1UL];

                        LSUINT32 ui32Mask = 0x80000000UL;
                        LSUINT32 ui32Used = 4UL;
                        while ( ui32Used && !_biRight.m_ui32Digits[--ui32Used] ) {}
                        ++ui32Used;
                        LSUINT32 ui32Value = _biRight.m_ui32Digits[ui32Used-1UL];
                        LSUINT32 ui32Shift = 0UL, ui32ResPos = 0UL;
                        while ( ui32Mask && (ui32Value & ui32Mask) == 0 ) {
                                ++ui32Shift;
                                ui32Mask >>= 1UL;
                        }

                        for ( LSUINT32 I = 4UL; I--; ) {
                                ui32Remainder[I] = _biLeft.m_ui32Digits[I];
                        }
                        ui32Remainder[4] = 0UL;

                        ShiftLeft( ui32Remainder, 5UL, ui32Shift );
                        C128BitInteger biNewRight = _biRight << ui32Shift;

                        LSUINT32 ui32RemainderUsed = 4UL;
                        while ( ui32RemainderUsed && !ui32Remainder[--ui32RemainderUsed] ) {}
                        ++ui32RemainderUsed;
                        LSUINT32 ui32NewRightUsed = 4UL;
                        while ( ui32NewRightUsed && !biNewRight.m_ui32Digits[--ui32NewRightUsed] ) {}
                        ++ui32NewRightUsed;

                        LSUINT32 ui32J = ui32RemainderUsed - ui32NewRightUsed;
                        LSUINT32 ui32Pos = ui32RemainderUsed - 1UL;

                        LSUINT32 ui32FirstDivisorByte = biNewRight.m_ui32Digits[ui32NewRightUsed-1UL];
                        LSUINT32 ui32SecondDivisorByte = biNewRight.m_ui32Digits[ui32NewRightUsed-2UL];

                        LSUINT32 ui32DivisorLen = ui32NewRightUsed + 1UL;
                        LSUINT32 ui32DividendPart[5] = { 0UL };

                        for ( ; ui32J > 0UL; --ui32J ) {
                                LSUINT64 ui64Dividend = (static_cast<LSUINT64>(ui32Remainder[ui32Pos]) << 32ULL) + ui32Remainder[ui32Pos-1UL];

                                LSUINT64 ui64Q = ui64Dividend / ui32FirstDivisorByte;
                                LSUINT64 ui64R = ui64Dividend % ui32FirstDivisorByte;

                                LSBOOL bDone = false;
                                while ( !bDone ) {
                                        bDone = true;

                                        if ( ui64Q == 0x100000000ULL ||
                                                (ui64Q * ui32SecondDivisorByte) > ((ui64R << 32UL) + ui32Remainder[ui32Pos-2UL]) ) {
                                                --ui64Q;
                                                ui64R += ui32FirstDivisorByte;
                                                if ( ui64R < 0x100000000ULL ) {
                                                        bDone = false;
                                                }
                                        }
                                }

                                for ( LSUINT32 I = 0UL; I < ui32DivisorLen; ++I ) {
                                        ui32DividendPart[I] = ui32Remainder[ui32Pos-I];
                                }

                                // Again on the heap instead of on the stack.
                                C128BitInteger biK( ui32DividendPart );
                                C128BitInteger biS( biNewRight * C128BitInteger( static_cast<LSUINT64>(ui64Q) ) );

                                while ( biS > biK ) {
                                        --ui64Q;
                                        biS = biS - biNewRight;
                                }

                                C128BitInteger liY = biK - biS;
                                for ( LSUINT32 I = 0UL; I < ui32DivisorLen; ++I ) {
                                        ui32Remainder[ui32Pos-I] = liY.m_ui32Digits[ui32NewRightUsed-I];
                                }

                                biResult.m_ui32Digits[ui32ResPos++] = static_cast<LSUINT32>(ui64Q);
                                --ui32Pos;
                        }

                        LSUINT32 Y = 0UL;
                        for ( LSINT32 X = static_cast<LSINT32>(ui32ResPos) - 1; X >= 0; --X, ++Y ) {
                                _biQuotient.m_ui32Digits[Y] = biResult.m_ui32Digits[X];
                        }

                        for ( ; Y < 4UL; ++Y ) {
                                _biQuotient.m_ui32Digits[Y] = 0UL;
                        }

                        LSUINT32 ui32Size = ShiftRight( ui32Remainder, ui32RemainderUsed, ui32Shift );
                        for ( Y = ui32Size; Y < 4UL; ++Y ) {
                                ui32Remainder[Y] = 0UL;
                        }
                        LSUINT64 * pui64Dest = reinterpret_cast<LSUINT64 *>(_biRemainder.m_ui32Digits);
                        LSUINT64 * pui64Src = reinterpret_cast<LSUINT64 *>(ui32Remainder);
                        (*pui64Dest++) = (*pui64Src++);
                        (*pui64Dest) = (*pui64Src);
                }

                static LSVOID LSE_CALL                                          DivideS( const C128BitInteger &_biLeft,
                        const C128BitInteger &_biRight,
                        C128BitInteger &_biQuotient,
                        C128BitInteger &_biRemainder ) {

                        C128BitInteger liResult( 0ULL );
                        LSUINT32 ui32ResPos = 0UL;

                        // Copy dividend to remainder.
                        _biRemainder = _biLeft;
                        LSINT32 i32Pos = 4;
                        while ( i32Pos && !_biRemainder.m_ui32Digits[--i32Pos] ) {}
                        ++i32Pos;

                        LSUINT64 ui64Divisor = _biRight.m_ui32Digits[0UL];
                        LSUINT64 ui64Dividend = _biRemainder.m_ui32Digits[i32Pos];

                        if ( ui64Dividend >= ui64Divisor ) {
                                LSUINT64 ui64Quotient = ui64Dividend / ui64Divisor;
                                liResult.m_ui32Digits[ui32ResPos++] = static_cast<LSUINT32>(ui64Quotient);
                                _biRemainder.m_ui32Digits[i32Pos] = static_cast<LSUINT32>(ui64Dividend % ui64Divisor);
                        }
                        --i32Pos;

                        while ( i32Pos >= 0 ) {
                                ui64Dividend = (static_cast<LSUINT64>(_biRemainder.m_ui32Digits[i32Pos+1]) << 32ULL) + _biRemainder.m_ui32Digits[i32Pos];
                                LSUINT64 ui64Quotient = ui64Dividend / ui64Divisor;
                                liResult.m_ui32Digits[ui32ResPos++] = static_cast<LSUINT32>(ui64Quotient);

                                _biRemainder.m_ui32Digits[i32Pos+1] = 0;
                                _biRemainder.m_ui32Digits[i32Pos--] = static_cast<LSUINT32>(ui64Dividend % ui64Divisor);
                        }

                        // Copy the result over the output quotient.
                        LSUINT32 J = 0UL;
                        for ( LSINT32 I = static_cast<LSINT32>(ui32ResPos) - 1; I >= 0; --I, ++J ) {
                                _biQuotient.m_ui32Digits[J] = liResult.m_ui32Digits[I];
                        }

                        for ( ; J < 4UL; ++J ) {
                                _biQuotient.m_ui32Digits[J] = 0;
                        }
                }

        };

}       // namespace lsstd

#endif  // __LSE_128BITINTEGER_H__