hg/stx-libbasic: comparison LargeInteger.st

equal deleted inserted replaced

-:940613fe6659
+:199b5e15b1da
 "
 COPYRIGHT (c) 1994 by Claus Gittinger
-	      All Rights Reserved
+All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 "{ Package: 'stx:libbasic' }"
 "{ NameSpace: Smalltalk }"
 Integer subclass:#LargeInteger
-	instanceVariableNames:'sign digitByteArray'
+instanceVariableNames:'sign digitByteArray'
-	classVariableNames:'UseKarazuba'
+classVariableNames:'UseKarazuba'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'Magnitude-Numbers'
+category:'Magnitude-Numbers'
 !
 !LargeInteger class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1994 by Claus Gittinger
-	      All Rights Reserved
+All Rights Reserved
 This software is furnished under a license and may be used
 only in accordance with the terms of that license and with the
 inclusion of the above copyright notice.   This software may not
 be provided or otherwise made available to, or used by, any
 128 bit numbers (which make up almost all instances in practice).
 As all of these are transparent to the outside world, any of it may or may not
 change in the future.
 [author:]
-	Claus Gittinger
+Claus Gittinger
 [see also:]
-	Number
+Number
-	Float Fraction FixedPoint
+Float Fraction FixedPoint
-	SmallInteger
+SmallInteger
 "
 !
 testing
 "
 v := last := 1.
 2 to:3000 do:[:i |
 i printCR.
 v := v * i.
 (v / i) ~= last ifTrue:[
-	   self halt
+self halt
 ].
 last := v.
 ]
 from the argument, aByteArray."
 |digits|
 msb == false ifTrue:[
-	digits := aByteArrayOfDigits
+digits := aByteArrayOfDigits
 ] ifFalse:[
-	digits := aByteArrayOfDigits reversed
+digits := aByteArrayOfDigits reversed
 ].
 ^ self basicNew setDigits:digits
 "
 (LargeInteger digitBytes:#[16r10 16r20 16r30 16r00] MSB:false) hexPrintString
 value:aSmallInteger
 "create and return a new LargeInteger with value taken from
 the argument, aSmallInteger.
 Notice:
-	this should be only used internally, since such small
+this should be only used internally, since such small
-	largeIntegers do not normally occur in the system.
+largeIntegers do not normally occur in the system.
-	(They are used by myself)
+(They are used by myself)
 May change/be removed without notice."
 ^ self basicNew value:aSmallInteger
 "LargeInteger value:3689"
 "
 this is the common case, multiplying with SmallInteger.
 Use a special method for this case ...
 "
 ((numberClass := aNumber class) == SmallInteger) ifTrue:[
-	^ self productFromInteger:aNumber
+^ self productFromInteger:aNumber
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (numberClass == self class) ifFalse:[
-	^ self retry:#* coercing:aNumber
+^ self retry:#* coercing:aNumber
 ].
 otherSign := aNumber sign.
 (sign == otherSign) ifTrue:[^ self absMul:aNumber].
 (otherSign == 0) ifTrue:[^ 0].
 "
 this is the common case, adding a SmallInteger.
 Use a special method for this case ...
 "
 ((numberClass := aNumber class) == SmallInteger) ifTrue:[
-	^ self sumFromInteger:aNumber
+^ self sumFromInteger:aNumber
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (numberClass == self class) ifFalse:[
-	^ self retry:#+ coercing:aNumber
+^ self retry:#+ coercing:aNumber
 ].
 otherSign := aNumber sign.
 (sign > 0) ifTrue:[
-	"I am positive"
+"I am positive"
-	(otherSign > 0) ifTrue:[^ self absPlus:aNumber sign:1].
+(otherSign > 0) ifTrue:[^ self absPlus:aNumber sign:1].
-	(otherSign < 0) ifTrue:[^ self absMinus:aNumber sign:1].
+(otherSign < 0) ifTrue:[^ self absMinus:aNumber sign:1].
-	^ self
+^ self
 ].
 "I am negative"
 (otherSign > 0) ifTrue:[^ aNumber absMinus:self sign:1].
 (otherSign < 0) ifTrue:[^ self absPlus:aNumber sign:-1].
 ^ self
 "
 this is the common case, subtracting a SmallInteger.
 Use a special method for this case ...
 "
 ((numberClass := aNumber class) == SmallInteger) ifTrue:[
-	sign > 0 ifTrue:[
+sign > 0 ifTrue:[
-	    aNumber > 0 ifTrue:[
+aNumber > 0 ifTrue:[
-		^ self absFastMinus:aNumber sign:1
+^ self absFastMinus:aNumber sign:1
-	    ].
+].
-	    ^ self absFastPlus:aNumber sign:1
+^ self absFastPlus:aNumber sign:1
-	].
+].
-	aNumber > 0 ifTrue:[
+aNumber > 0 ifTrue:[
-	    ^ self absFastPlus:aNumber sign:-1
+^ self absFastPlus:aNumber sign:-1
-	].
+].
-	^ self absFastMinus:aNumber sign:-1
+^ self absFastMinus:aNumber sign:-1
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (numberClass == self class) ifFalse:[
-	^ self retry:#- coercing:aNumber
+^ self retry:#- coercing:aNumber
 ].
 otherSign := aNumber sign.
 (sign > 0) ifTrue:[
-	"I am positive"
+"I am positive"
-	(otherSign > 0) ifTrue:[
+(otherSign > 0) ifTrue:[
-	    "+large - +large"
+"+large - +large"
-	    ^ self absMinus:aNumber sign:1
+^ self absMinus:aNumber sign:1
-	].
+].
-	(otherSign < 0) ifTrue:[
+(otherSign < 0) ifTrue:[
-	    "+large - -large"
+"+large - -large"
-	    ^ self absPlus:aNumber sign:1
+^ self absPlus:aNumber sign:1
-	].
+].
-	"should not happen"
+"should not happen"
-	^ self
+^ self
 ].
 "I am negative"
 (otherSign > 0) ifTrue:[
-	"-large - +large"
+"-large - +large"
-	^ self absPlus:aNumber sign:-1
+^ self absPlus:aNumber sign:-1
 ].
 (otherSign < 0) ifTrue:[
-	"-large - -large"
+"-large - -large"
-	^ self absMinus:aNumber sign:-1
+^ self absMinus:aNumber sign:-1
 ].
 ^ self
 "
 12345678901234567890 - 0
 / aNumber
 "return the quotient of the receiver and the argument, aNumber"
 aNumber isInteger ifTrue:[
-	^ Fraction numerator:self denominator:aNumber
+^ Fraction numerator:self denominator:aNumber
 ].
 aNumber isFraction ifTrue:[
-	^ Fraction numerator:(self * aNumber denominator) denominator:(aNumber numerator)
+^ Fraction numerator:(self * aNumber denominator) denominator:(aNumber numerator)
 ].
 "this is a q&d hack - we loose lots of precision here ..."
 ^ (self asFloat / aNumber asFloat)
 Use a special method for this case ...
 "
 (cls == SmallInteger) ifTrue:[
 abs := aNumber.
 abs := abs abs.
-(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
+(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r0fffffffffff ifFalse:16r00ffffff)) ifTrue:[
 divMod := self absFastDivMod:abs.
 ] ifFalse:[
 n := abs asLargeInteger.
 ].
 ] ifFalse:[
 negative infinity.
 m < |aNumber| AND there is an integer k with (k * aNumber + m) = self
 The returned remainder has the same sign as aNumber.
 The following is always true:
-	(receiver // aNumber) * aNumber + (receiver \\ aNumber) = receiver
+(receiver // aNumber) * aNumber + (receiver \\ aNumber) = receiver
 Be careful with negative results: 9 // 4 -> 2, while -9 // 4 -> -3.
 Especially surprising:
-	-1 \\ 10 -> 9  (because -(1/10) is truncated towards next smaller integer, which is -1,
+-1 \\ 10 -> 9  (because -(1/10) is truncated towards next smaller integer, which is -1,
-			and -1 multiplied by 10 gives -10, so we have to add 9 to get the original -1).
+and -1 multiplied by 10 gives -10, so we have to add 9 to get the original -1).
-	-10 \\ 3 -> 2 (because -(10/3) is truncated towards next smaller integer, which is -4,
+-10 \\ 3 -> 2 (because -(10/3) is truncated towards next smaller integer, which is -4,
-			and -4 * 4 gives -12, so we need to add 2 to get the original -10.
+and -4 * 4 gives -12, so we need to add 2 to get the original -10.
 See #rem: which is the corresponding remainder for division via #quo:.
 Redefined here for speed."
 |abs rem negativeDivisor|
 aNumber negative ifTrue:[
-	negativeDivisor := true.
+negativeDivisor := true.
-	abs := aNumber negated.
+abs := aNumber negated.
 ] ifFalse:[
-	negativeDivisor := false.
+negativeDivisor := false.
-	abs := aNumber.
+abs := aNumber.
 ].
 "
 this is the common case, dividing by a SmallInteger.
 Use a special method for this case ...
 "
 (aNumber class == SmallInteger) ifTrue:[
-	(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
+(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
-	    rem := (self absFastDivMod:abs) at:2.
+rem := (self absFastDivMod:abs) at:2.
-	] ifFalse:[
+] ifFalse:[
-	    rem := self absMod:abs asLargeInteger
+rem := self absMod:abs asLargeInteger
-	].
+].
 ] ifFalse:[
-	"
+"
-	 if the argument is not a largeInteger, coerce
+if the argument is not a largeInteger, coerce
-	"
+"
-	(aNumber class == self class) ifFalse:[
+(aNumber class == self class) ifFalse:[
-	    ^ self retry:#\\ coercing:aNumber
+^ self retry:#\\ coercing:aNumber
-	].
+].
-	rem := self absMod:abs.
+rem := self absMod:abs.
 ].
 rem = 0 ifFalse:[
-	negativeDivisor ifTrue:[
+negativeDivisor ifTrue:[
-	    rem := rem setSign:-1
+rem := rem setSign:-1
-	].
+].
-	(self negative ~~ negativeDivisor) ifTrue:[
+(self negative ~~ negativeDivisor) ifTrue:[
-	    "different sign, so remainder would have been negative.
+"different sign, so remainder would have been negative.
-	     rem has been rounded toward zero, this code will simulate
+rem has been rounded toward zero, this code will simulate
-	     rounding to negative infinity."
+rounding to negative infinity."
-	    rem := aNumber - rem.
+rem := aNumber - rem.
-	].
+].
 ].
 ^ rem
 "
 (9000000000 \\ 4000000000)   = (900 \\ 400 * 10000000)  ifFalse:[self halt].
 "Created: / 26.10.1999 / 21:28:06 / stefan"
 !
 divMod:aNumber
 "return an array filled with
-	(self // aNumber) and (self \\ aNumber).
+(self // aNumber) and (self \\ aNumber).
 The returned remainder has the same sign as aNumber.
 The following is always true:
-	(receiver // something) * something + (receiver \\ something) = receiver
+(receiver // something) * something + (receiver \\ something) = receiver
 Be careful with negative results: 9 // 4 -> 2, while -9 // 4 -> -3.
 Especially surprising:
-	-1 \\ 10 -> 9  (because -(1/10) is truncated towards next smaller integer, which is -1,
+-1 \\ 10 -> 9  (because -(1/10) is truncated towards next smaller integer, which is -1,
-			and -1 multiplied by 10 gives -10, so we have to add 9 to get the original -1).
+and -1 multiplied by 10 gives -10, so we have to add 9 to get the original -1).
-	-10 \\ 3 -> 2 (because -(10/3) is truncated towards next smaller integer, which is -4,
+-10 \\ 3 -> 2 (because -(10/3) is truncated towards next smaller integer, which is -4,
-			and -4 * 4 gives -12, so we need to add 2 to get the original -10.
+and -4 * 4 gives -12, so we need to add 2 to get the original -10.
 This is redefined here for more performance
 (as the remainder is generated as a side effect of division)"
 |cls n|
 ((self < 0) or:[aNumber <= 0]) ifTrue:[
-	^ super divMod:aNumber
+^ super divMod:aNumber
 ].
 "/ only handle the common case here
 cls := aNumber class.
 (cls == SmallInteger) ifTrue:[
-	"
+"
-	 this is the common case, dividing by a SmallInteger.
+this is the common case, dividing by a SmallInteger.
-	 Use a special method for this case ...
+Use a special method for this case ...
-	"
+"
-	(aNumber between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
+(aNumber between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffffff ifFalse:16r00ffffff)) ifTrue:[
-	    ^ self absFastDivMod:aNumber abs.
+^ self absFastDivMod:aNumber abs.
-	].
+].
-	n := aNumber asLargeInteger.
+n := aNumber asLargeInteger.
 ] ifFalse:[
-	(cls == self class) ifFalse:[
+(cls == self class) ifFalse:[
-	    ^ super divMod:aNumber
+^ super divMod:aNumber
-	].
+].
-	n := aNumber.
+n := aNumber.
 ].
 ^ self absDivMod:n abs.
 "
 The result is truncated toward zero (which is different from //, which
 truncates toward negative infinity).
 The results sign is negative if the receiver has a sign
 different from the args sign.
 The following is always true:
-	(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
+(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
 "
 |otherSign quo abs "{ Class: SmallInteger }" |
 otherSign := aNumber sign.
 "
 this is the common case, dividing by a SmallInteger.
 Use a special method for this case ...
 "
 (aNumber class == SmallInteger) ifTrue:[
-	abs := aNumber.
+abs := aNumber.
-	abs := abs abs.
+abs := abs abs.
-	(abs between:1 and:16r00ffffff) ifTrue:[
+(abs between:1 and:16r00ffffff) ifTrue:[
-	    quo := (self absFastDivMod:abs) at:1.
+quo := (self absFastDivMod:abs) at:1.
-	    (sign == otherSign) ifTrue:[^ quo].
+(sign == otherSign) ifTrue:[^ quo].
-	    ^ quo setSign:-1
+^ quo setSign:-1
-	]
+]
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (aNumber class == self class) ifFalse:[
-	^ self retry:#quo: coercing:aNumber
+^ self retry:#quo: coercing:aNumber
 ].
 sign < 0 ifTrue:[
-	(sign == otherSign) ifTrue:[^ (self absDivMod:aNumber negated) at:1].
+(sign == otherSign) ifTrue:[^ (self absDivMod:aNumber negated) at:1].
 ] ifFalse:[
-	(sign == otherSign) ifTrue:[^ (self absDivMod:aNumber) at:1].
+(sign == otherSign) ifTrue:[^ (self absDivMod:aNumber) at:1].
 ].
 ^ ((self absDivMod:aNumber) at:1) setSign:-1
 "
 900 // 400
 rem:aNumber
 "return the remainder of division of the receiver by the argument, aNumber.
 The returned remainder has the same sign as the receiver.
 The following is always true:
-	(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
+(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
 "
 |rem abs "{ Class: SmallInteger }" |
 "
 this is the common case, dividing by a SmallInteger.
 Use special code for this case ...
 "
 (aNumber class == SmallInteger) ifTrue:[
-	abs := aNumber.
+abs := aNumber.
-	abs := abs abs.
+abs := abs abs.
-	(abs between:1 and:16r00ffffff) ifTrue:[
+(abs between:1 and:16r00ffffff) ifTrue:[
-	    rem := (self absFastDivMod:abs) at:2.
+rem := (self absFastDivMod:abs) at:2.
-	] ifFalse:[
+] ifFalse:[
-	    rem := self absMod:abs asLargeInteger
+rem := self absMod:abs asLargeInteger
-	].
+].
 ] ifFalse:[
-	"
+"
-	 if the argument is not a largeInteger, coerce
+if the argument is not a largeInteger, coerce
-	"
+"
-	(aNumber class == self class) ifFalse:[
+(aNumber class == self class) ifFalse:[
-	    ^ self retry:#rem coercing:aNumber
+^ self retry:#rem coercing:aNumber
-	].
+].
-	rem := self absMod:aNumber
+rem := self absMod:aNumber
 ].
 sign < 0 ifTrue:[
-	^ rem setSign:-1
+^ rem setSign:-1
 ].
 ^ rem
 "
 900 \\ 400
 bitAnd:anInteger
 "return the bitwise-and of the receiver and the argument, anInteger"
 %{  /* NOCONTEXT */
 if (__isSmallInteger(anInteger)) {
-	INT v2 = __intVal(anInteger);
+INT v2 = __intVal(anInteger);
-	INT v1;
+INT v1;
 #if defined(__LSBFIRST__)
-	v1 = *(INT *)(__byteArrayVal(__INST(digitByteArray)));
+v1 = *(INT *)(__byteArrayVal(__INST(digitByteArray)));
 #else
-	unsigned char *digits = (unsigned char *)(__byteArrayVal(__INST(digitByteArray)));
+unsigned char *digits = (unsigned char *)(__byteArrayVal(__INST(digitByteArray)));
-	v1 = digits[0] & 0xFF;
+v1 = digits[0] & 0xFF;
-	v1 = v1 | ((digits[1] & 0xFF)<<8);
+v1 = v1 | ((digits[1] & 0xFF)<<8);
-	v1 = v1 | ((digits[2] & 0xFF)<<16);
+v1 = v1 | ((digits[2] & 0xFF)<<16);
-	v1 = v1 | ((digits[3] & 0xFF)<<24);
+v1 = v1 | ((digits[3] & 0xFF)<<24);
 # if (__POINTER_SIZE__ == 8)
-	v1 = v1 | ((digits[4] & 0xFF)<<32);
+v1 = v1 | ((digits[4] & 0xFF)<<32);
-	v1 = v1 | ((digits[5] & 0xFF)<<40);
+v1 = v1 | ((digits[5] & 0xFF)<<40);
-	v1 = v1 | ((digits[6] & 0xFF)<<48);
+v1 = v1 | ((digits[6] & 0xFF)<<48);
-	v1 = v1 | ((digits[7] & 0xFF)<<56);
+v1 = v1 | ((digits[7] & 0xFF)<<56);
 #endif
 #endif
-	RETURN ( __mkSmallInteger(v1 & v2) );
+RETURN ( __mkSmallInteger(v1 & v2) );
 }
 if (__isLargeInteger(anInteger)) {
-	OBJ _myDigitByteArray = __INST(digitByteArray);
+OBJ _myDigitByteArray = __INST(digitByteArray);
-	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(anInteger)->l_digits;
+OBJ _otherDigitByteArray = __LargeIntegerInstPtr(anInteger)->l_digits;
-	if (__isByteArray(_myDigitByteArray)
+if (__isByteArray(_myDigitByteArray)
-	 && __isByteArray(_otherDigitByteArray)) {
+&& __isByteArray(_otherDigitByteArray)) {
-	    unsigned char *pDigits1, *pDigits2;
+unsigned char *pDigits1, *pDigits2;
-	    int size1, size2, minSize;
+int size1, size2, minSize;
-	    union {
+union {
-		double d;                    // force align
+double d;                    // force align
-		unsigned char chars[2048+8];
+unsigned char chars[2048+8];
-	    } buffer;
+} buffer;
-	    unsigned char *pRslt;
+unsigned char *pRslt;
-	    OBJ newDigits, newLarge;
+OBJ newDigits, newLarge;
-	    pDigits1 = (unsigned char *)(__byteArrayVal(_myDigitByteArray));
+pDigits1 = (unsigned char *)(__byteArrayVal(_myDigitByteArray));
-	    pDigits2 = (unsigned char *)(__byteArrayVal(_otherDigitByteArray));
+pDigits2 = (unsigned char *)(__byteArrayVal(_otherDigitByteArray));
-	    pRslt = (void *)(buffer.chars);
+pRslt = (void *)(buffer.chars);
-	    size1 = __byteArraySize(_myDigitByteArray);
+size1 = __byteArraySize(_myDigitByteArray);
-	    size2 = __byteArraySize(_otherDigitByteArray);
+size2 = __byteArraySize(_otherDigitByteArray);
-	    minSize = (size1 < size2) ? size1 : size2;
+minSize = (size1 < size2) ? size1 : size2;
-	    if (minSize <= sizeof(buffer.chars)) {
+if (minSize <= sizeof(buffer.chars)) {
-		int n = minSize;
+int n = minSize;
-	    /* not worth it - but a nice try and first testbed for mmx... */
+/* not worth it - but a nice try and first testbed for mmx... */
 #define x__USE_MMX__
 #ifdef __USE_MMX__
 #ifdef __VISUALC__
-		if (((INT)pRslt & 7) == 0) {    // 8-byte aligned
+if (((INT)pRslt & 7) == 0) {    // 8-byte aligned
-		    if (((INT)pDigits1 & 7) == ((INT)pDigits2 & 7)) {   // same align
+if (((INT)pDigits1 & 7) == ((INT)pDigits2 & 7)) {   // same align
-			while (((INT)pDigits1 & 7) && (n >= sizeof(int))) {
+while (((INT)pDigits1 & 7) && (n >= sizeof(int))) {
-			    ((int *)pRslt)[0] = ((int *)pDigits1)[0] & ((int *)pDigits2)[0];
+((int *)pRslt)[0] = ((int *)pDigits1)[0] & ((int *)pDigits2)[0];
-			    pRslt += sizeof(int);
+pRslt += sizeof(int);
-			    pDigits1 += sizeof(int);
+pDigits1 += sizeof(int);
-			    pDigits2 += sizeof(int);
+pDigits2 += sizeof(int);
-			    pDigits2 += sizeof(int);
+pDigits2 += sizeof(int);
-			    n -= sizeof(int);
+n -= sizeof(int);
-			}
+}
-			for (; n >= 8; n -= 8) {
+for (; n >= 8; n -= 8) {
-			    __asm {
+__asm {
-				mov eax, pDigits1
+mov eax, pDigits1
-				movq mm0, [eax]
+movq mm0, [eax]
-				mov eax, pDigits2
+mov eax, pDigits2
-				movq mm1, [eax]
+movq mm1, [eax]
-				pand mm0, mm1
+pand mm0, mm1
-				mov eax, pRslt
+mov eax, pRslt
-				movq [eax], mm0
+movq [eax], mm0
-			    }
+}
-			    pDigits1 += 8;
+pDigits1 += 8;
-			    pDigits2 += 8;
+pDigits2 += 8;
-			    pRslt += 8;
+pRslt += 8;
-			}
+}
-			__asm {
+__asm {
-			    emms ; switch back to FPU state.
+emms ; switch back to FPU state.
-			}
+}
-		    }
+}
-		}
+}
 #endif /* __VISUALC__ */
 #endif /* __USE_MMX__ */
-		for (; n >= sizeof(INT)*4; n -= sizeof(INT)*4) {
+for (; n >= sizeof(INT)*4; n -= sizeof(INT)*4) {
-		    ((INT *)pRslt)[0] = ((INT *)pDigits1)[0] & ((INT *)pDigits2)[0];
+((INT *)pRslt)[0] = ((INT *)pDigits1)[0] & ((INT *)pDigits2)[0];
-		    ((INT *)pRslt)[1] = ((INT *)pDigits1)[1] & ((INT *)pDigits2)[1];
+((INT *)pRslt)[1] = ((INT *)pDigits1)[1] & ((INT *)pDigits2)[1];
-		    ((INT *)pRslt)[2] = ((INT *)pDigits1)[2] & ((INT *)pDigits2)[2];
+((INT *)pRslt)[2] = ((INT *)pDigits1)[2] & ((INT *)pDigits2)[2];
-		    ((INT *)pRslt)[3] = ((INT *)pDigits1)[3] & ((INT *)pDigits2)[3];
+((INT *)pRslt)[3] = ((INT *)pDigits1)[3] & ((INT *)pDigits2)[3];
-		    pRslt += sizeof(INT)*4;
+pRslt += sizeof(INT)*4;
-		    pDigits1 += sizeof(INT)*4;
+pDigits1 += sizeof(INT)*4;
-		    pDigits2 += sizeof(INT)*4;
+pDigits2 += sizeof(INT)*4;
-		}
+}
-		for (; n >= sizeof(INT); n -= sizeof(INT)) {
+for (; n >= sizeof(INT); n -= sizeof(INT)) {
-		    ((INT *)pRslt)[0] = ((INT *)pDigits1)[0] & ((INT *)pDigits2)[0];
+((INT *)pRslt)[0] = ((INT *)pDigits1)[0] & ((INT *)pDigits2)[0];
-		    pRslt += sizeof(INT);
+pRslt += sizeof(INT);
-		    pDigits1 += sizeof(INT);
+pDigits1 += sizeof(INT);
-		    pDigits2 += sizeof(INT);
+pDigits2 += sizeof(INT);
-		}
+}
-		for (; n > 0; n--) {
+for (; n > 0; n--) {
-		    *pRslt = *pDigits1 & *pDigits2;
+*pRslt = *pDigits1 & *pDigits2;
-		    pRslt++;
+pRslt++;
-		    pDigits1++;
+pDigits1++;
-		    pDigits2++;
+pDigits2++;
-		}
+}
-		// normalize
+// normalize
-		while ((pRslt[-1]==0) && (pRslt > buffer.chars)) {
+while ((pRslt[-1]==0) && (pRslt > buffer.chars)) {
-		    pRslt--;
+pRslt--;
-		}
+}
-		// allocate result
+// allocate result
-		n = pRslt-buffer.chars;
+n = pRslt-buffer.chars;
-		if (n <= sizeof(INT)) {
+if (n <= sizeof(INT)) {
-		    INT val = 0;
+INT val = 0;
-		    // make it a smallInteger / 32bitInteger
+// make it a smallInteger / 32bitInteger
-		    while (n > 0) {
+while (n > 0) {
-			val = (val << 8) + buffer.chars[--n];
+val = (val << 8) + buffer.chars[--n];
-		    }
+}
-		    RETURN (__MKUINT(val));
+RETURN (__MKUINT(val));
-		}
+}
-		newDigits = __MKBYTEARRAY(buffer.chars, n);
+newDigits = __MKBYTEARRAY(buffer.chars, n);
-		if (newDigits) {
+if (newDigits) {
-		    __PROTECT__(newDigits);
+__PROTECT__(newDigits);
-		    newLarge = __STX___new(sizeof(struct __LargeInteger));
+newLarge = __STX___new(sizeof(struct __LargeInteger));
-		    __UNPROTECT__(newDigits);
+__UNPROTECT__(newDigits);
-		    if (newLarge) {
+if (newLarge) {
-			__InstPtr(newLarge)->o_class = LargeInteger; __STORE(newLarge, LargeInteger);
+__InstPtr(newLarge)->o_class = LargeInteger; __STORE(newLarge, LargeInteger);
-			__LargeIntegerInstPtr(newLarge)->l_digits = newDigits; __STORE(newLarge, newDigits);
+__LargeIntegerInstPtr(newLarge)->l_digits = newDigits; __STORE(newLarge, newDigits);
-			__LargeIntegerInstPtr(newLarge)->l_sign = __MKSMALLINT(1);
+__LargeIntegerInstPtr(newLarge)->l_sign = __MKSMALLINT(1);
-			RETURN (newLarge);
+RETURN (newLarge);
-		    }
+}
-		}
+}
-	    }
+}
-	}
+}
 }
 %}.
 ^ super bitAnd:anInteger
 "
 |len1 len2 newBytes|
 anInteger class ~~ LargeInteger ifTrue:[^ super bitXor:anInteger].
 (len1 := anInteger digitLength) > (len2 := self digitLength) ifTrue:[
-	newBytes := anInteger digitBytes copy.
+newBytes := anInteger digitBytes copy.
-	newBytes bitXorBytesFrom:1 to:len2 with:digitByteArray startingAt:1
+newBytes bitXorBytesFrom:1 to:len2 with:digitByteArray startingAt:1
 ] ifFalse:[
-	newBytes := digitByteArray copy.
+newBytes := digitByteArray copy.
-	newBytes bitXorBytesFrom:1 to:len1 with:anInteger digits startingAt:1
+newBytes bitXorBytesFrom:1 to:len1 with:anInteger digits startingAt:1
 ].
 ^ (self class digitBytes:newBytes) compressed
 "
 (16r112233445566778899 bitXor:16rFF                ) printStringRadix:16 '112233445566778866'
 |bigNum1 bigNum2|
 bigNum1 := 2 raisedToInteger:512.
 bigNum2 := 2 raisedToInteger:510.
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	   bigNum1 bitXor:bigNum2.
+bigNum1 bitXor:bigNum2.
-	]
+]
 ]
 "
 !
 lowBit
 /*
 * quickly advance over full 0-words
 */
 if (__isByteArray(__digitByteArray)) {
-	int __sz = __byteArraySize(__digitByteArray);
+int __sz = __byteArraySize(__digitByteArray);
-	unsigned char *__bP = __byteArrayVal(__digitByteArray);
+unsigned char *__bP = __byteArrayVal(__digitByteArray);
-	unsigned char *__bP0 = __bP;
+unsigned char *__bP0 = __bP;
-	sz = __MKSMALLINT(__sz);
+sz = __MKSMALLINT(__sz);
 #ifdef __UNROLL_LOOPS__
-	while (__sz > (sizeof(INT) * 4)) {
+while (__sz > (sizeof(INT) * 4)) {
-	    if (( ((INT *)__bP)[0]
+if (( ((INT *)__bP)[0]
-		 | ((INT *)__bP)[1]
+| ((INT *)__bP)[1]
-		 | ((INT *)__bP)[2]
+| ((INT *)__bP)[2]
-		 | ((INT *)__bP)[3] ) != 0) break;
+| ((INT *)__bP)[3] ) != 0) break;
-	    __sz -= sizeof(INT) * 4;
+__sz -= sizeof(INT) * 4;
-	    __bP += sizeof(INT) * 4;
+__bP += sizeof(INT) * 4;
-	}
+}
 #endif
-	while (__sz > sizeof(INT)) {
+while (__sz > sizeof(INT)) {
-	    if ( ((INT *)__bP)[0] != 0 ) break;
+if ( ((INT *)__bP)[0] != 0 ) break;
-	    __sz -= sizeof(INT);
+__sz -= sizeof(INT);
-	    __bP += sizeof(INT);
+__bP += sizeof(INT);
-	}
+}
-	while (__sz > 0) {
+while (__sz > 0) {
-	    unsigned int c;
+unsigned int c;
-	    if ( (c = *__bP) != 0 ) {
+if ( (c = *__bP) != 0 ) {
-		int bitIdx = (__bP - __bP0) * 8;
+int bitIdx = (__bP - __bP0) * 8;
 #ifdef __BSF
-		{
+{
-		    int index;
+int index;
-		    int t = c;
+int t = c;
-		    index = __BSF(t);
+index = __BSF(t);
-		    RETURN ( __mkSmallInteger(index + 1 + bitIdx) );
+RETURN ( __mkSmallInteger(index + 1 + bitIdx) );
-		}
+}
 #else
-		if (c & 0x0F) {
+if (c & 0x0F) {
-		    if (c & 0x03) {
+if (c & 0x03) {
-			if (c & 0x01) {
+if (c & 0x01) {
-			    RETURN ( __mkSmallInteger( bitIdx + 1) );
+RETURN ( __mkSmallInteger( bitIdx + 1) );
-			} else {
+} else {
-			    RETURN ( __mkSmallInteger( bitIdx + 2) );
+RETURN ( __mkSmallInteger( bitIdx + 2) );
-			}
+}
-		    } else {
+} else {
-			if (c & 0x04) {
+if (c & 0x04) {
-			    RETURN ( __mkSmallInteger( bitIdx + 3) );
+RETURN ( __mkSmallInteger( bitIdx + 3) );
-			} else {
+} else {
-			    RETURN ( __mkSmallInteger( bitIdx + 4) );
+RETURN ( __mkSmallInteger( bitIdx + 4) );
-			}
+}
-		    }
+}
-		} else {
+} else {
-		    if (c & 0x30) {
+if (c & 0x30) {
-			if (c & 0x10) {
+if (c & 0x10) {
-			    RETURN ( __mkSmallInteger( bitIdx + 5) );
+RETURN ( __mkSmallInteger( bitIdx + 5) );
-			} else {
+} else {
-			    RETURN ( __mkSmallInteger( bitIdx + 6) );
+RETURN ( __mkSmallInteger( bitIdx + 6) );
-			}
+}
-		    } else {
+} else {
-			if (c & 0x40) {
+if (c & 0x40) {
-			    RETURN ( __mkSmallInteger( bitIdx + 7) );
+RETURN ( __mkSmallInteger( bitIdx + 7) );
-			} else {
+} else {
-			    RETURN ( __mkSmallInteger( bitIdx + 8) );
+RETURN ( __mkSmallInteger( bitIdx + 8) );
-			}
+}
-		    }
+}
-		}
+}
 #endif
-		break;
+break;
-	    }
+}
-	    __sz--;
+__sz--;
-	    __bP++;
+__bP++;
-	}
+}
-	idx0 = __mkSmallInteger( __bP - __bP0 + 1 );
+idx0 = __mkSmallInteger( __bP - __bP0 + 1 );
 }
 %}.
 "/ never actually reached
 idx0 to:sz do:[:digitIndex |
-	(byte := digitByteArray at:digitIndex) ~~ 0 ifTrue:[
+(byte := digitByteArray at:digitIndex) ~~ 0 ifTrue:[
-	    ^ (digitIndex-1)*8 + (byte lowBit)
+^ (digitIndex-1)*8 + (byte lowBit)
-	]
+]
 ].
 ^ 0 "/ should not happen
 "
 (1 bitShift:0) lowBit
 (1 bitShift:1000) highBit
 ((1 bitShift:64)-1) lowBit
 ((1 bitShift:64)-1) highBit
 1 to:1000 do:[:idx |
-	self assert:(( 1 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 1 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 1 bitShift:idx) lowBit = ( 1 bitShift:idx) highBit).
+self assert:(( 1 bitShift:idx) lowBit = ( 1 bitShift:idx) highBit).
-	self assert:(( 3 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 3 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 7 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 7 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 15 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 15 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 31 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 31 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 63 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 63 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 127 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 127 bitShift:idx) lowBit = (idx+1)).
-	self assert:(( 255 bitShift:idx) lowBit = (idx+1)).
+self assert:(( 255 bitShift:idx) lowBit = (idx+1)).
 ]
 |num|
 num := (1 bitShift:1000).
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    num lowBit
+num lowBit
-	]
+]
 ]
 "
 "Modified: 14.8.1997 / 11:55:34 / cg"
 ! !
 !LargeInteger methodsFor:'bit operators - indexed'!
 bitAt:anIntegerIndex
 "return the value of the index's bit (index starts at 1) as 0 or 1.
 Notice: the result of bitAt: on negative receivers is not
-	     defined in the language standard (since the implementation
+defined in the language standard (since the implementation
-	     is free to choose any internal representation for integers)"
+is free to choose any internal representation for integers)"
 %{  /* NOCONTEXT */
 if (__isSmallInteger(anIntegerIndex)) {
-	INT idx = __smallIntegerVal(anIntegerIndex) - 1;
+INT idx = __smallIntegerVal(anIntegerIndex) - 1;
-	if (idx >= 0) {
+if (idx >= 0) {
-	    int v1;
+int v1;
-	    int byteOffset = idx / 8;
+int byteOffset = idx / 8;
-	    int digitLen   = __byteArraySize(__INST(digitByteArray));
+int digitLen   = __byteArraySize(__INST(digitByteArray));
-	    if (digitLen < byteOffset) {
+if (digitLen < byteOffset) {
-		RETURN(__mkSmallInteger(0));
+RETURN(__mkSmallInteger(0));
-	    }
+}
-	    v1 = (__byteArrayVal(__INST(digitByteArray)))[byteOffset];
+v1 = (__byteArrayVal(__INST(digitByteArray)))[byteOffset];
-	    if (v1 & (1 << (idx % 8))) {
+if (v1 & (1 << (idx % 8))) {
-		RETURN(__mkSmallInteger(1));
+RETURN(__mkSmallInteger(1));
-	    } else {
+} else {
-		RETURN(__mkSmallInteger(0));
+RETURN(__mkSmallInteger(0));
-	    }
+}
-	}
+}
 }
 %}.
 ^ super bitAt:anIntegerIndex
 "
 but a new number is returned. Should be named #withBitSet:"
 |myDigitLength newDigitLength newDigitBytes byteIndexOfBitToSet|
 index <= 0 ifTrue:[
-	^ SubscriptOutOfBoundsSignal
+^ SubscriptOutOfBoundsSignal
-		raiseRequestWith:index
+raiseRequestWith:index
-		errorString:'index out of bounds'
+errorString:'index out of bounds'
 ].
 myDigitLength := digitByteArray size.
 byteIndexOfBitToSet := ((index-1)//8)+1.
 byteIndexOfBitToSet > myDigitLength ifTrue:[
-	newDigitLength := myDigitLength max:byteIndexOfBitToSet.
+newDigitLength := myDigitLength max:byteIndexOfBitToSet.
-	newDigitBytes := ByteArray new:newDigitLength.
+newDigitBytes := ByteArray new:newDigitLength.
-	newDigitBytes replaceFrom:1 to:myDigitLength with:digitByteArray startingAt:1.
+newDigitBytes replaceFrom:1 to:myDigitLength with:digitByteArray startingAt:1.
 ] ifFalse:[
-	newDigitBytes := digitByteArray copy
+newDigitBytes := digitByteArray copy
 ].
 newDigitBytes
-	at:byteIndexOfBitToSet
+at:byteIndexOfBitToSet
-	put:((newDigitBytes at:byteIndexOfBitToSet) setBit:(((index-1)\\8)+1)).
+put:((newDigitBytes at:byteIndexOfBitToSet) setBit:(((index-1)\\8)+1)).
 ^ self class digitBytes:newDigitBytes sign:sign
 "
 TestCase assert:( 16r80000000 setBit:3  ) = 16r80000004
 TestCase assert:( 16r80000000 setBit:33 ) = 16r180000000
 unsigned INT bits;
 int count;
 if (__isSmallInteger(shiftCount)) {
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	count = count % 32;
+count = count % 32;
-	bits = __unsignedLongIntVal(self);
+bits = __unsignedLongIntVal(self);
-	if (count > 0) {
+if (count > 0) {
-	    bits = (bits << count) | (bits >> (32-count));
+bits = (bits << count) | (bits >> (32-count));
-	} else {
+} else {
-	    bits = (bits >> (-count)) | (bits << (32-(-count)));
+bits = (bits >> (-count)) | (bits << (32-(-count)));
-	}
+}
 #if __POINTER_SIZE__ == 8
-	bits &= 0xFFFFFFFFL;
+bits &= 0xFFFFFFFFL;
 #endif
-	RETURN (__MKUINT(bits));
+RETURN (__MKUINT(bits));
 }
 %}.
 ^ self primitiveFailed
 "
 unsigned INT bits;
 int count;
 if (__isSmallInteger(shiftCount)) {
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	if (count >= 32) {
+if (count >= 32) {
-	    RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	}
+}
-	bits = __unsignedLongIntVal(self);
+bits = __unsignedLongIntVal(self);
-	if (count > 0) {
+if (count > 0) {
-	    bits = bits << count;
+bits = bits << count;
-	} else {
+} else {
-	    bits = bits >> (-count);
+bits = bits >> (-count);
-	}
+}
 #if __POINTER_SIZE__ == 8
-	bits &= 0xFFFFFFFFL;
+bits &= 0xFFFFFFFFL;
 #endif
-	RETURN (__MKUINT(bits));
+RETURN (__MKUINT(bits));
 }
 %}.
 ^ self primitiveFailed
 "
 %{
 unsigned INT swapped;
 swapped = ( (__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[0]) << 24)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[1]) << 16)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[1]) << 16)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[2]) << 8)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[2]) << 8)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[3]));
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[3]));
 RETURN (__MKUINT(swapped));
 %}.
+^ super byteSwapped32
-"
-(LargeInteger value:16r11223344) byteSwapped hexPrintString
+"
-(LargeInteger value:16r44332211) byteSwapped hexPrintString
+(LargeInteger value:16r11223344) byteSwapped32 hexPrintString
-16r88776655 byteSwapped hexPrintString
+(LargeInteger value:16r44332211) byteSwapped32 hexPrintString
-16r11223344 byteSwapped hexPrintString
+16r88776655 byteSwapped32 hexPrintString
+16r11223344 byteSwapped32 hexPrintString
 "
 "Created: / 31-01-2012 / 11:07:42 / cg"
 !
 unsigned INT swappedLO = 0;
 unsigned INT swappedHI;
 unsigned INT swapped;
 swappedHI = ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[0]) << 24)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[1]) << 16)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[1]) << 16)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[2]) << 8)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[2]) << 8)
-	      | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[3]));
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[3]));
 if (__byteArraySize(__INST(digitByteArray)) > 4) {
-	swappedLO = ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[4]) << 24)
+swappedLO = ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[4]) << 24)
-		  | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[5]) << 16)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[5]) << 16)
-		  | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[6]) << 8)
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[6]) << 8)
-		  | ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[7]));
+| ((__ByteArrayInstPtr(__INST(digitByteArray))->ba_element[7]));
 }
 #if __POINTER_SIZE__ == 8
 swapped = (swappedHI<<32) | swappedLO;
 RETURN(__MKUINT( swapped ));
 #else
 RETURN(__MKLARGEINT64(1, swappedLO, swappedHI));
 #endif
 %}.
+^ super byteSwapped64
 "
 (LargeInteger value:16r11223344) byteSwapped64 hexPrintString
 (LargeInteger value:16r44332211) byteSwapped64 hexPrintString
 (LargeInteger value:16r1122334455667788) byteSwapped64 hexPrintString
 return context._RETURN( STInteger._new( ((STLargeInteger)self).digitLength() ));
 #endif
 %}.
 l := digitByteArray size.
 [l ~~ 0 and:[(digitByteArray at:l) == 0]] whileTrue:[
-	l := l - 1.
+l := l - 1.
 ].
 ^ l
 "Modified: 31.7.1997 / 13:18:28 / cg"
 !
 %{  /* NOCONTEXT */
 OBJ t;
 if (__INST(sign) == __mkSmallInteger(0)) {
-	RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
 }
 t = __INST(digitByteArray);
 if (__isByteArray(t)) {
-	unsigned char *__digitBytes = __ByteArrayInstPtr(t)->ba_element;
+unsigned char *__digitBytes = __ByteArrayInstPtr(t)->ba_element;
-	int _idx, _idx0;
+int _idx, _idx0;
-	INT _val;
+INT _val;
-	_idx = _idx0 = __byteArraySize(t);
+_idx = _idx0 = __byteArraySize(t);
-	while ((_idx > 0) && (__digitBytes[_idx - 1] == 0)) {
+while ((_idx > 0) && (__digitBytes[_idx - 1] == 0)) {
-	    _idx--;
+_idx--;
-	}
+}
 #if __POINTER_SIZE__ == 8
-	switch (_idx) {
+switch (_idx) {
-	    case 8:
+case 8:
-		_val = __digitBytes[7];
+_val = __digitBytes[7];
-		if (_val <= 0x40) {
+if (_val <= 0x40) {
-		    _val = (_val<<8);
+_val = (_val<<8);
-		    _val = (_val + __digitBytes[6]) << 8;
+_val = (_val + __digitBytes[6]) << 8;
-		    _val = (_val + __digitBytes[5]) << 8;
+_val = (_val + __digitBytes[5]) << 8;
-		    _val = (_val + __digitBytes[4]) << 8;
+_val = (_val + __digitBytes[4]) << 8;
-		    _val = (_val + __digitBytes[3]) << 8;
+_val = (_val + __digitBytes[3]) << 8;
-		    _val = (_val + __digitBytes[2]) << 8;
+_val = (_val + __digitBytes[2]) << 8;
-		    _val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		    _val += __digitBytes[0];
+_val += __digitBytes[0];
-		    if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-			_val = -_val;
+_val = -_val;
-		    if (__ISVALIDINTEGER(_val)) {
+if (__ISVALIDINTEGER(_val)) {
-			RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-		    }
+}
-		}
+}
-		break;
+break;
-	    case 7:
+case 7:
 # if defined(__LSBFIRST__)
-		_val = ((INT *)__digitBytes)[0] & 0x00FFFFFFFFFFFFFFL;
+_val = ((INT *)__digitBytes)[0] & 0x00FFFFFFFFFFFFFFL;
 # else
-		_val = (__digitBytes[6]<<8);
+_val = (__digitBytes[6]<<8);
-		_val = (_val + __digitBytes[5]) << 8;
+_val = (_val + __digitBytes[5]) << 8;
-		_val = (_val + __digitBytes[4]) << 8;
+_val = (_val + __digitBytes[4]) << 8;
-		_val = (_val + __digitBytes[3]) << 8;
+_val = (_val + __digitBytes[3]) << 8;
-		_val = (_val + __digitBytes[2]) << 8;
+_val = (_val + __digitBytes[2]) << 8;
-		_val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		_val += __digitBytes[0];
+_val += __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 6:
+case 6:
 # if defined(__LSBFIRST__)
-		_val = ((INT *)__digitBytes)[0] & 0x0000FFFFFFFFFFFFL;
+_val = ((INT *)__digitBytes)[0] & 0x0000FFFFFFFFFFFFL;
 # else
-		_val = (__digitBytes[5]<<8);
+_val = (__digitBytes[5]<<8);
-		_val = (_val + __digitBytes[4]) << 8;
+_val = (_val + __digitBytes[4]) << 8;
-		_val = (_val + __digitBytes[3]) << 8;
+_val = (_val + __digitBytes[3]) << 8;
-		_val = (_val + __digitBytes[2]) << 8;
+_val = (_val + __digitBytes[2]) << 8;
-		_val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		_val += __digitBytes[0];
+_val += __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 5:
+case 5:
 # if defined(__LSBFIRST__)
-		_val = ((INT *)__digitBytes)[0] & 0x000000FFFFFFFFFFL;
+_val = ((INT *)__digitBytes)[0] & 0x000000FFFFFFFFFFL;
 # else
-		_val = (__digitBytes[4]<<8);
+_val = (__digitBytes[4]<<8);
-		_val = (_val + __digitBytes[3]) << 8;
+_val = (_val + __digitBytes[3]) << 8;
-		_val = (_val + __digitBytes[2]) << 8;
+_val = (_val + __digitBytes[2]) << 8;
-		_val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		_val += __digitBytes[0];
+_val += __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 4:
+case 4:
 # if defined(__LSBFIRST__)
-		_val = ((INT *)__digitBytes)[0] & 0x00000000FFFFFFFFL;
+_val = ((INT *)__digitBytes)[0] & 0x00000000FFFFFFFFL;
 # else
-		_val = (__digitBytes[3]<<8);
+_val = (__digitBytes[3]<<8);
-		_val = (_val + __digitBytes[2]) << 8;
+_val = (_val + __digitBytes[2]) << 8;
-		_val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		_val += __digitBytes[0];
+_val += __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 3:
+case 3:
 # if defined(__LSBFIRST__)
-		_val = ((int *)__digitBytes)[0] & 0x00FFFFFF;
+_val = ((int *)__digitBytes)[0] & 0x00FFFFFF;
 # else
-		_val = (__digitBytes[2]<<8);
+_val = (__digitBytes[2]<<8);
-		_val = (_val + __digitBytes[1]) << 8;
+_val = (_val + __digitBytes[1]) << 8;
-		_val += __digitBytes[0];
+_val += __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 2:
+case 2:
 # if defined(__LSBFIRST__)
-		_val = ((int *)__digitBytes)[0] & 0x0000FFFF;
+_val = ((int *)__digitBytes)[0] & 0x0000FFFF;
 # else
-		_val = (__digitBytes[1]<<8) + __digitBytes[0];
+_val = (__digitBytes[1]<<8) + __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 1:
+case 1:
-		_val = __digitBytes[0];
+_val = __digitBytes[0];
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    case 0:
+case 0:
-		RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	}
+}
 #else
-	if (_idx <= 4) {
+if (_idx <= 4) {
-	    if (_idx <= 2) {
+if (_idx <= 2) {
-		if (_idx == 0) {
+if (_idx == 0) {
-		    RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-		}
+}
-		if (_idx == 1) {
+if (_idx == 1) {
-		    _val = __digitBytes[0];
+_val = __digitBytes[0];
-		    if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-			_val = -_val;
+_val = -_val;
-		    RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-		}
+}
 # if defined(__LSBFIRST__)
-		_val = ((int *)__digitBytes)[0] & 0x0000FFFF;
+_val = ((int *)__digitBytes)[0] & 0x0000FFFF;
 # else
-		_val = (__digitBytes[1]<<8) + __digitBytes[0];
+_val = (__digitBytes[1]<<8) + __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    }
+}
-	    if (_idx == 3) {
+if (_idx == 3) {
 # if defined(__LSBFIRST__)
-		_val = ((int *)__digitBytes)[0] & 0x00FFFFFF;
+_val = ((int *)__digitBytes)[0] & 0x00FFFFFF;
 # else
-		_val = (((__digitBytes[2]<<8) + __digitBytes[1])<<8) + __digitBytes[0];
+_val = (((__digitBytes[2]<<8) + __digitBytes[1])<<8) + __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-	    }
+}
-	    _val = __digitBytes[3];
+_val = __digitBytes[3];
-	    if (_val <= 0x40) {
+if (_val <= 0x40) {
 # if defined(__LSBFIRST__)
-		_val = ((int *)__digitBytes)[0];
+_val = ((int *)__digitBytes)[0];
 # else
-		_val = (((((_val<<8) + __digitBytes[2])<<8) + __digitBytes[1])<<8) + __digitBytes[0];
+_val = (((((_val<<8) + __digitBytes[2])<<8) + __digitBytes[1])<<8) + __digitBytes[0];
 # endif
-		if (__INST(sign) == __mkSmallInteger(-1))
+if (__INST(sign) == __mkSmallInteger(-1))
-		    _val = -_val;
+_val = -_val;
-		if (__ISVALIDINTEGER(_val)) {
+if (__ISVALIDINTEGER(_val)) {
-		    RETURN (__mkSmallInteger(_val));
+RETURN (__mkSmallInteger(_val));
-		}
+}
-	    }
+}
-	}
+}
 #endif
-	if (_idx == _idx0) {
+if (_idx == _idx0) {
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	/*
+/*
-	 * must copy & cut off some (zero)bytes
+* must copy & cut off some (zero)bytes
-	 */
+*/
-	{
+{
-	    OBJ newDigits;
+OBJ newDigits;
-	    OBJ oldDigits;
+OBJ oldDigits;
-	    /*
+/*
-	     * careful - there is no context here to protect
+* careful - there is no context here to protect
-	     * the receiver ...
+* the receiver ...
-	     */
+*/
-	    __PROTECT__(self);
+__PROTECT__(self);
-	    __PROTECT__(__INST(digitByteArray));
+__PROTECT__(__INST(digitByteArray));
-	    newDigits = __BYTEARRAY_UNINITIALIZED_NEW_INT(_idx);
+newDigits = __BYTEARRAY_UNINITIALIZED_NEW_INT(_idx);
-	    __UNPROTECT__(oldDigits);
+__UNPROTECT__(oldDigits);
-	    __UNPROTECT__(self);
+__UNPROTECT__(self);
-	    if (newDigits) {
+if (newDigits) {
-		bcopy(__ByteArrayInstPtr(oldDigits)->ba_element,
+bcopy(__ByteArrayInstPtr(oldDigits)->ba_element,
-		      __ByteArrayInstPtr(newDigits)->ba_element,
+__ByteArrayInstPtr(newDigits)->ba_element,
-		      _idx);
+_idx);
-		__INST(digitByteArray) = newDigits; __STORE(self, newDigits);
+__INST(digitByteArray) = newDigits; __STORE(self, newDigits);
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    /*
+/*
-	     * allocation failed ...
+* allocation failed ...
-	     * ... fall through to trigger the error
+* ... fall through to trigger the error
-	     */
+*/
-	}
+}
 }
 %}.
 index0 := index := digitByteArray size.
 [(index > 0) and:[(digitByteArray at:index) == 0]] whileTrue:[
-	index := index - 1
+index := index - 1
 ].
 "/    ((index < SmallInteger maxBytes)
 "/    or:[(index == SmallInteger maxBytes)
 "/            and:[(digitByteArray at:index) < 16r20]])
 "/    ifTrue:[
 "/            val := val bitOr:(digitByteArray at:i).
 "/        ].
 "/        ^ val * sign
 "/    ].
 (index ~~ index0) ifTrue:[
-	digitByteArray := digitByteArray copyFrom:1 to:index
+digitByteArray := digitByteArray copyFrom:1 to:index
 ].
 ^ self
 !
 generality
 could have simply created a 4-byte largeinteger and normalize it.
 The code below does the normalize right away, avoiding the
 overhead of producing any intermediate byte-arrays (and the scanning)
 "
 (aSmallInteger == 0) ifTrue: [
-	digitByteArray := ByteArray with:0.
+digitByteArray := ByteArray with:0.
-	sign := 0.
+sign := 0.
-	^ self
+^ self
 ].
 (aSmallInteger < 0) ifTrue: [
-	sign := -1.
+sign := -1.
-	absValue := aSmallInteger negated
+absValue := aSmallInteger negated
 ] ifFalse: [
-	sign := 1.
+sign := 1.
-	absValue := aSmallInteger
+absValue := aSmallInteger
 ].
 b1 := absValue bitAnd:16rFF.
 absValue := absValue bitShift:-8.
 absValue == 0 ifTrue:[
-	digitByteArray := ByteArray with:b1
+digitByteArray := ByteArray with:b1
 ] ifFalse:[
-	b2 := absValue bitAnd:16rFF.
+b2 := absValue bitAnd:16rFF.
-	absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-	absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-	    digitByteArray := ByteArray with:b1 with:b2
+digitByteArray := ByteArray with:b1 with:b2
-	] ifFalse:[
+] ifFalse:[
-	    b3 := absValue bitAnd:16rFF.
+b3 := absValue bitAnd:16rFF.
-	    absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-	    absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-		digitByteArray := ByteArray with:b1 with:b2 with:b3
+digitByteArray := ByteArray with:b1 with:b2 with:b3
-	    ] ifFalse:[
+] ifFalse:[
-		b4 := absValue bitAnd:16rFF.
+b4 := absValue bitAnd:16rFF.
-		absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-		absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-		    digitByteArray := ByteArray with:b1 with:b2 with:b3 with:b4
+digitByteArray := ByteArray with:b1 with:b2 with:b3 with:b4
-		] ifFalse:[
+] ifFalse:[
-		    b5 := absValue bitAnd:16rFF.
+b5 := absValue bitAnd:16rFF.
-		    absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-		    absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-			digitByteArray := ByteArray new:5.
+digitByteArray := ByteArray new:5.
-			digitByteArray at:1 put:b1.
+digitByteArray at:1 put:b1.
-			digitByteArray at:2 put:b2.
+digitByteArray at:2 put:b2.
-			digitByteArray at:3 put:b3.
+digitByteArray at:3 put:b3.
-			digitByteArray at:4 put:b4.
+digitByteArray at:4 put:b4.
-			digitByteArray at:5 put:b5.
+digitByteArray at:5 put:b5.
-		    ] ifFalse:[
+] ifFalse:[
-			b6 := absValue bitAnd:16rFF.
+b6 := absValue bitAnd:16rFF.
-			absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-			absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-			    digitByteArray := ByteArray new:6.
+digitByteArray := ByteArray new:6.
-			    digitByteArray at:1 put:b1.
+digitByteArray at:1 put:b1.
-			    digitByteArray at:2 put:b2.
+digitByteArray at:2 put:b2.
-			    digitByteArray at:3 put:b3.
+digitByteArray at:3 put:b3.
-			    digitByteArray at:4 put:b4.
+digitByteArray at:4 put:b4.
-			    digitByteArray at:5 put:b5.
+digitByteArray at:5 put:b5.
-			    digitByteArray at:6 put:b6.
+digitByteArray at:6 put:b6.
-			] ifFalse:[
+] ifFalse:[
-			    b7 := absValue bitAnd:16rFF.
+b7 := absValue bitAnd:16rFF.
-			    absValue := absValue bitShift:-8.
+absValue := absValue bitShift:-8.
-			    absValue == 0 ifTrue:[
+absValue == 0 ifTrue:[
-				digitByteArray := ByteArray new:7.
+digitByteArray := ByteArray new:7.
-				digitByteArray at:1 put:b1.
+digitByteArray at:1 put:b1.
-				digitByteArray at:2 put:b2.
+digitByteArray at:2 put:b2.
-				digitByteArray at:3 put:b3.
+digitByteArray at:3 put:b3.
-				digitByteArray at:4 put:b4.
+digitByteArray at:4 put:b4.
-				digitByteArray at:5 put:b5.
+digitByteArray at:5 put:b5.
-				digitByteArray at:6 put:b6.
+digitByteArray at:6 put:b6.
-				digitByteArray at:7 put:b7.
+digitByteArray at:7 put:b7.
-			    ] ifFalse:[
+] ifFalse:[
-				digitByteArray := ByteArray new:8.
+digitByteArray := ByteArray new:8.
-				digitByteArray at:1 put:b1.
+digitByteArray at:1 put:b1.
-				digitByteArray at:2 put:b2.
+digitByteArray at:2 put:b2.
-				digitByteArray at:3 put:b3.
+digitByteArray at:3 put:b3.
-				digitByteArray at:4 put:b4.
+digitByteArray at:4 put:b4.
-				digitByteArray at:5 put:b5.
+digitByteArray at:5 put:b5.
-				digitByteArray at:6 put:b6.
+digitByteArray at:6 put:b6.
-				digitByteArray at:7 put:b7.
+digitByteArray at:7 put:b7.
-				digitByteArray at:8 put:absValue.
+digitByteArray at:8 put:absValue.
-			    ]
+]
-			]
+]
-		    ]
+]
-		]
+]
-	    ]
+]
-	]
+]
 ]
 "Modified: / 26.5.1999 / 22:18:14 / cg"
 ! !
 "return true, if the argument, aNumber is greater than the receiver"
 |otherSign|
 (aNumber class == self class) ifTrue:[
-	otherSign := aNumber sign.
+otherSign := aNumber sign.
-	(sign > 0) ifTrue:[
+(sign > 0) ifTrue:[
-	    "I am positive"
+"I am positive"
-	    (otherSign > 0) ifTrue:[^ self absLess:aNumber].
+(otherSign > 0) ifTrue:[^ self absLess:aNumber].
-	    ^ false "aNumber is <= 0"
+^ false "aNumber is <= 0"
-	].
+].
-	"I am negative"
+"I am negative"
-	(otherSign > 0) ifTrue:[^ true].
+(otherSign > 0) ifTrue:[^ true].
-	(otherSign == 0) ifTrue:[^ true].
+(otherSign == 0) ifTrue:[^ true].
-	^ (aNumber absLess:self)
+^ (aNumber absLess:self)
 ].
 (aNumber class == SmallInteger) ifTrue:[
-	otherSign := aNumber sign.
+otherSign := aNumber sign.
-	(sign > 0) ifTrue:[
+(sign > 0) ifTrue:[
-	    "I am positive"
+"I am positive"
-	    ^ false "aNumber is <= 0"
+^ false "aNumber is <= 0"
-	].
+].
-	(sign == 0) ifTrue:[
+(sign == 0) ifTrue:[
-	    (otherSign > 0) ifTrue:[^ true].
+(otherSign > 0) ifTrue:[^ true].
-	    ^ false
+^ false
-	].
+].
-	"I am negative"
+"I am negative"
-	^ true
+^ true
 ].
 "/ hack for epsilon tests
 (aNumber class == Float) ifTrue:[
-	self negative ifTrue:[
+self negative ifTrue:[
-	    "/ I am a large negative; so my value is definitely below SmallInteger minVal
+"/ I am a large negative; so my value is definitely below SmallInteger minVal
-	    aNumber >= SmallInteger minVal asFloat ifTrue:[^ true].
+aNumber >= SmallInteger minVal asFloat ifTrue:[^ true].
-	] ifFalse:[
+] ifFalse:[
-	    "/ I am a large positive; so my value is definitely above SmallInteger maxVal
+"/ I am a large positive; so my value is definitely above SmallInteger maxVal
-	    aNumber <= SmallInteger maxVal asFloat ifTrue:[^ false].
+aNumber <= SmallInteger maxVal asFloat ifTrue:[^ false].
-	].
+].
 ].
 ^ aNumber lessFromInteger:self
 "Modified: / 31.7.2002 / 10:08:19 / cg"
 as the receiver, false otherwise"
 "/ speed up compare to 0
 (aNumber == 0) ifTrue:[
-	^ sign == 0
+^ sign == 0
 ].
 (aNumber class == self class) ifFalse:[
-	"/
+"/
-	"/ here, we depend on the fact, that largeinteger
+"/ here, we depend on the fact, that largeinteger
-	"/ results are always converted to smallInts, if possible.
+"/ results are always converted to smallInts, if possible.
-	"/ therefore, a largeInt in the smallInt range is not allowed (possible)
+"/ therefore, a largeInt in the smallInt range is not allowed (possible)
-	"/
+"/
-	aNumber class == SmallInteger ifTrue:[^ false ].
+aNumber class == SmallInteger ifTrue:[^ false ].
-	^ aNumber equalFromInteger:self
+^ aNumber equalFromInteger:self
 ].
 (aNumber sign == sign) ifFalse:[^ false].
 ^ digitByteArray = aNumber digitBytes "/ ^ self absEq:aNumber
 "return true, if the argument, aNumber is less than the receiver"
 |otherSign|
 (aNumber class == self class) ifFalse:[
-	^ (aNumber < self)
+^ (aNumber < self)
 ].
 otherSign := aNumber sign.
 (sign > 0) ifTrue:[
-	"I am positive"
+"I am positive"
-	(otherSign > 0) ifTrue:[^ aNumber absLess:self].
+(otherSign > 0) ifTrue:[^ aNumber absLess:self].
-	^ true "aNumber is <= 0"
+^ true "aNumber is <= 0"
 ].
 (sign == 0) ifTrue:[
-	"I am zero"
+"I am zero"
-	(otherSign > 0) ifTrue:[^ false].
+(otherSign > 0) ifTrue:[^ false].
-	^ true
+^ true
 ].
 "I am negative"
 (otherSign > 0) ifTrue:[^ false].
 (otherSign == 0) ifTrue:[^ false].
 ^ (self absLess:aNumber)
 h := self bitAnd:16r3FFFFFFF.
 l := digitByteArray size.
 l >= 8 ifTrue:[
-	h := h bitXor:(digitByteArray at:l).
+h := h bitXor:(digitByteArray at:l).
-	h := h bitXor:((digitByteArray at:l-1) bitShift:8).
+h := h bitXor:((digitByteArray at:l-1) bitShift:8).
-	h := h bitXor:((digitByteArray at:l-2) bitShift:16).
+h := h bitXor:((digitByteArray at:l-2) bitShift:16).
-	h := h bitXor:((digitByteArray at:l-3) bitShift:22).
+h := h bitXor:((digitByteArray at:l-3) bitShift:22).
-	l >= 12 ifTrue:[
+l >= 12 ifTrue:[
-	    m := l // 2.
+m := l // 2.
-	    h := h bitXor:(digitByteArray at:m-1).
+h := h bitXor:(digitByteArray at:m-1).
-	    h := h bitXor:((digitByteArray at:m) bitShift:8).
+h := h bitXor:((digitByteArray at:m) bitShift:8).
-	    h := h bitXor:((digitByteArray at:m+1) bitShift:16).
+h := h bitXor:((digitByteArray at:m+1) bitShift:16).
-	    h := h bitXor:((digitByteArray at:m+2) bitShift:22).
+h := h bitXor:((digitByteArray at:m+2) bitShift:22).
-	].
+].
-	^ h
+^ h
 ].
 ^ (h bitShift:3) + l
 "
 16r80000000 hash
 differenceFromInteger:anInteger
 "sent, when anInteger does not know how to subtract the receiver.
 Return the result of 'anInteger - self'. The argument must be a SmallInteger."
 anInteger > 0 ifTrue:[
-	sign > 0 ifTrue:[
+sign > 0 ifTrue:[
-	    ^ self absFastMinus:anInteger sign:-1
+^ self absFastMinus:anInteger sign:-1
-	].
+].
-	^ self absFastPlus:anInteger sign:1
+^ self absFastPlus:anInteger sign:1
 ].
 anInteger == 0 ifTrue:[
-	^ self negated
+^ self negated
 ].
 sign > 0 ifTrue:[
-	^ self absFastPlus:anInteger negated sign:-1
+^ self absFastPlus:anInteger negated sign:-1
 ].
 self > anInteger ifTrue:[
-	^ self absFastMinus:anInteger asLargeInteger sign:-1
+^ self absFastMinus:anInteger asLargeInteger sign:-1
 ] ifFalse:[
-	^ anInteger asLargeInteger absFastMinus:self sign:-1
+^ anInteger asLargeInteger absFastMinus:self sign:-1
 ].
 "
 12345678901234567890
 -12345678901234567890
 "/ results are always converted to smallInts, if possible.
 "/ therefore, a largeInt in the smallInt range is not allowed (possible)
 "/
 anInteger class == SmallInteger ifTrue:[^ false ].
 anInteger class == self class ifFalse:[
-	^ super equalFromInteger:anInteger
+^ super equalFromInteger:anInteger
 ].
 (anInteger sign == sign) ifFalse:[^ false].
 ^ self absEq:anInteger
 !
 "trivial cases"
 anInteger == 0 ifTrue:[^ 0].
 anInteger == 1 ifTrue:[^ self].
 num := anInteger abs.
-(num > 16r3FFFFF) ifTrue:[
+SmallInteger maxBytes == 8 ifTrue:[
-	"if num is too big (so that multiplying by a byte could create a Large)"
+(num > 16r3FFFFFFF) ifTrue:[
+"if num is too big (so that multiplying by a byte could create a Large)"
-	^ anInteger retry:#* coercing:self
+^ anInteger retry:#* coercing:self
+].
+] ifFalse:[
+(num > 16r3FFFFF) ifTrue:[
+"if num is too big (so that multiplying by a byte could create a Large)"
+^ anInteger retry:#* coercing:self
+].
 ].
 len := digitByteArray size.
 val := num.
 val <= 16rFF ifTrue:[
-	lResult := len + 1.
+lResult := len + 1.
 ] ifFalse:[
-	val <= 16rFFFF ifTrue:[
+val <= 16rFFFF ifTrue:[
-	    lResult := len + 2
+lResult := len + 2
-	] ifFalse:[
+] ifFalse:[
-	    val <= 16rFFFFFF ifTrue:[
+val <= 16rFFFFFF ifTrue:[
-		lResult := len + 4.
+lResult := len + 4.
-	    ] ifFalse:[
+] ifFalse:[
-		lResult := len + 6.
+val <= 16rFFFFFFFF ifTrue:[
-	    ]
+lResult := len + 6.
-	]
+] ifFalse:[
+val <= 16rFFFFFFFFFF ifTrue:[
+lResult := len + 8.
+] ifFalse:[
+val <= 16rFFFFFFFFFF ifTrue:[
+lResult := len + 10.
+] ifFalse:[
+val <= 16rFFFFFFFFFFFF ifTrue:[
+lResult := len + 12.
+] ifFalse:[
+lResult := len + 14.
+]
+]
+]
+]
+]
+]
 ].
 resultDigitByteArray := ByteArray uninitializedNew:lResult.
 result := self class basicNew setDigits:resultDigitByteArray.
 anInteger < 0 ifTrue:[
-	sign > 0 ifTrue:[
+sign > 0 ifTrue:[
-	    result setSign:-1
+result setSign:-1
-	].
+].
 ] ifFalse:[
-	sign < 0 ifTrue:[
+sign < 0 ifTrue:[
-	    result setSign:sign
+result setSign:sign
-	]
+]
 ].
 ok := false.
 %{
 OBJ __digitByteArray = __INST(digitByteArray);
 if (__isSmallInteger(len)
 && __isByteArray(__digitByteArray)
 && __isByteArray(resultDigitByteArray)) {
-	INT _l = __intVal(len);
+INT _l = __intVal(len);
-	INT _v = __intVal(val);
+INT _v = __intVal(val);
-	unsigned INT _carry = 0;
+unsigned INT _carry = 0;
-	unsigned INT _prod;
+unsigned INT _prod;
-	unsigned char *digitP = __ByteArrayInstPtr(__digitByteArray)->ba_element;
+unsigned char *digitP = __ByteArrayInstPtr(__digitByteArray)->ba_element;
-	unsigned char *resultP = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
+unsigned char *resultP = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
-	/*
+/*
-	 * skipping zeros does not help much (a few percent) on
+* skipping zeros does not help much (a few percent) on
-	 * a P5 or other CPUS with a fast multiplier.
+* a P5 or other CPUS with a fast multiplier.
-	 * It may make more of a difference on CPUs with slower 0-multiply.
+* It may make more of a difference on CPUs with slower 0-multiply.
-	 */
+* Late news: it actually hurts modern x86_64 cpus.
-	while ((_l >= sizeof(INT)) && (((unsigned INT *)digitP)[0] == 0)) {
+* So only reenable for specific CPUs after concrete benchmarks.
-	    ((unsigned INT *)resultP)[0] = 0;
+*/
-	    digitP += sizeof(INT);
+#if 0
-	    resultP += sizeof(INT);
+while ((_l >= sizeof(INT)) && (((unsigned INT *)digitP)[0] == 0)) {
-	    _l -= sizeof(INT);
+((unsigned INT *)resultP)[0] = 0;
-	}
+digitP += sizeof(INT);
+resultP += sizeof(INT);
+_l -= sizeof(INT);
+}
+#endif
 #if defined(__LSBFIRST__)
 # if defined (__GNUC__) && defined(__i386__) && (__POINTER_SIZE__ == 4)
-	/*
+/*
-	 * can do it long-word-wise;
+* can do it long-word-wise;
-	 * 32*32 -> 64 multiplication
+* 32*32 -> 64 multiplication
-	 */
+*/
-	while (_l > 3) {
+while (_l > 3) {
-	    unsigned __pHi, __pLow;
+unsigned __pHi, __pLow;
-	    unsigned __digit;
+unsigned __digit;
-	    /*
+/*
-	     * max: 0xFFFF.FFFF * 0xFFFF.FFFF -> 0xFFFF.FFFE.0000.0001
+* max: 0xFFFF.FFFF * 0xFFFF.FFFF -> 0xFFFF.FFFE.0000.0001
-	     * + maxCarry (0xFFFF.FFFF)  -> 0xFFFF.FFFF.0000.0000
+* + maxCarry (0xFFFF.FFFF)  -> 0xFFFF.FFFF.0000.0000
-	     */
+*/
-	    __digit = ((unsigned long *)digitP)[0];
+__digit = ((unsigned long *)digitP)[0];
-	    asm ("mull %3               \n\
+asm ("mull %3               \n\
-		  addl %4,%%eax         \n\
+addl %4,%%eax         \n\
-		  adcl $0,%%edx"
+adcl $0,%%edx"
-		    : "=a"  (__pLow),
+: "=a"  (__pLow),
-		      "=d"  (__pHi)
+"=d"  (__pHi)
-		    : "0"   (__digit),
+: "0"   (__digit),
-		      "1"   ((unsigned long)(_v)),
+"1"   ((unsigned long)(_v)),
-		      "rm"  ((unsigned long)(_carry)) );
+"rm"  ((unsigned long)(_carry)) );
-	    ((unsigned long *)resultP)[0] = __pLow;
+((unsigned long *)resultP)[0] = __pLow;
-	    _carry = __pHi;
+_carry = __pHi;
-	    digitP += 4;
+digitP += 4;
-	    resultP += 4;
+resultP += 4;
-	    _l -= 4;
+_l -= 4;
-	}
+}
 # else /* not GNU-i386 */
 #  if defined(WIN32) && defined(__BORLANDC__) && defined(__i386__) && (__POINTER_SIZE__ == 4)
-	/*
+/*
-	 * can do it long-word-wise;
+* can do it long-word-wise;
-	 * 32*32 -> 64 multiplication
+* 32*32 -> 64 multiplication
-	 */
+*/
-	while (_l > 3) {
+while (_l > 3) {
-	    unsigned __pLow;
+unsigned __pLow;
-	    unsigned digit;
+unsigned digit;
-	    /*
+/*
-	     * max: 0xFFFF.FFFF * 0xFFFF.FFFF -> 0xFFFF.FFFE.0000.0001
+* max: 0xFFFF.FFFF * 0xFFFF.FFFF -> 0xFFFF.FFFE.0000.0001
-	     * + maxCarry (0xFFFF.FFFF)  -> 0xFFFF.FFFF.0000.0000
+* + maxCarry (0xFFFF.FFFF)  -> 0xFFFF.FFFF.0000.0000
-	     */
+*/
 /*
-	    digit = ((unsigned long *)digitP)[0];
+digit = ((unsigned long *)digitP)[0];
-	    edx::eax = (digit * _v);
+edx::eax = (digit * _v);
-	    edx::eax += _carry;
+edx::eax += _carry;
-	    ((unsigned long *)resultP)[0] = eax; -- pLow
+((unsigned long *)resultP)[0] = eax; -- pLow
-	    _carry = edx; -- pHigh
+_carry = edx; -- pHigh
-	    digitP += 4;
+digitP += 4;
-	    resultP += 4;
+resultP += 4;
 */
-	    digit = ((unsigned long *)digitP)[0];
+digit = ((unsigned long *)digitP)[0];
-	    asm {
+asm {
-		mov   eax, digit
+mov   eax, digit
-		mov   edx, _v
+mov   edx, _v
-		mul   edx
+mul   edx
-		add   eax, _carry
+add   eax, _carry
-		adc   edx, 0
+adc   edx, 0
-		mov   __pLow, eax
+mov   __pLow, eax
-		mov   _carry, edx
+mov   _carry, edx
-	    }
+}
-	    ((unsigned long *)resultP)[0] = __pLow;
+((unsigned long *)resultP)[0] = __pLow;
-	    digitP += 4;
+digitP += 4;
-	    resultP += 4;
+resultP += 4;
-	    _l -= 4;
+_l -= 4;
-	}
+}
 #  else /* not WIN32-i386 */
 #   if defined(INT64)
-	if (_v <= 0xFFFFFFFFL) {
+if (_v <= 0xFFFFFFFFL) {
-	    /*
+/* have 64bit ints; can do it int-wise
-	     * have a 64bit int type ... good
+*
-	     */
+* max: 0xFFFFFFFF * 0xFFFFFFFF -> 0xFFFFFFFE.0001
-	    UINT64 _prod64;
+* + maxCarry (0xFFFFFFFF)  -> 0xFFFFFFFF.0000
+*/
-	    /* have 64bit ints; can do it int-wise
+while (_l >= (4+4+4+4)) {
-	     *
+unsigned __t1, __t2, __t3, __t4;
-	     * max: 0xFFFFFFFF * 0xFFFFFFFF -> 0xFFFFFFFE.0001
+UINT64 _prod64a, _prod64b, _prod64c, _prod64d;
-	     * + maxCarry (0xFFFFFFFF)  -> 0xFFFFFFFF.0000
-	     */
+__t1 = ((unsigned *)digitP)[0];
-	    while (_l > 3) {
+_prod64a = (INT64)_v;
-		unsigned __t;
+_prod64a *= __t1;
+_prod64a += _carry;
-		__t = ((unsigned *)digitP)[0];
+((unsigned *)resultP)[0] = _prod64a /* & 0xFFFFFFFFL */;
-		digitP += 4;
+_carry = _prod64a >> 32;
-		_prod64 = (INT64)_v;
-		_prod64 *= __t;
+__t2 = ((unsigned *)digitP)[1];
-		_prod64 += _carry;
+_prod64b = (INT64)_v;
-		((unsigned *)resultP)[0] = _prod64 /* & 0xFFFFFFFFL */;
+_prod64b *= __t2;
-		_carry = _prod64 >> 32;
+_prod64b += _carry;
-		resultP += 4;
+((unsigned *)resultP)[1] = _prod64b /* & 0xFFFFFFFFL */;
-		_l -= 4;
+_carry = _prod64b >> 32;
-	    }
-	    if (_l > 1) {
+__t3 = ((unsigned *)digitP)[2];
-		unsigned short __t;
+_prod64c = (INT64)_v;
+_prod64c *= __t3;
-		__t = ((unsigned short *)digitP)[0];
+_prod64c += _carry;
-		digitP += 2;
+((unsigned *)resultP)[2] = _prod64c /* & 0xFFFFFFFFL */;
-		_prod64 = (INT64)_v;
+_carry = _prod64c >> 32;
-		_prod64 *= __t;
-		_prod64 += _carry;
+__t4 = ((unsigned *)digitP)[3];
-		((unsigned short *)resultP)[0] = _prod64 /* & 0xFFFF */;
+_prod64d = (INT64)_v;
-		_carry = _prod64 >> 16;
+_prod64d *= __t4;
-		resultP += 2;
+_prod64d += _carry;
-		_l -= 2;
+((unsigned *)resultP)[3] = _prod64d /* & 0xFFFFFFFFL */;
-	    }
+_carry = _prod64d >> 32;
-	    if (_l > 0) {
-		_prod64 = *digitP++ * _v + _carry;
+digitP += (4+4+4+4);
-		*resultP++ = _prod64 /* & 0xFF */;
+resultP += (4+4+4+4);
-		_carry = _prod64 >> 8;
+_l -= (4+4+4+4);
-		_l--;
+}
-	    }
+while (_l >= 4) {
-	}
+unsigned __t;
+UINT64 _prod64;
+__t = ((unsigned *)digitP)[0];
+digitP += 4;
+_prod64 = (INT64)_v;
+_prod64 *= __t;
+_prod64 += _carry;
+((unsigned *)resultP)[0] = _prod64 /* & 0xFFFFFFFFL */;
+_carry = _prod64 >> 32;
+resultP += 4;
+_l -= 4;
+}
+if (_l >= 2) {
+unsigned short __t;
+UINT64 _prod64;
+__t = ((unsigned short *)digitP)[0];
+digitP += 2;
+_prod64 = (INT64)_v;
+_prod64 *= __t;
+_prod64 += _carry;
+((unsigned short *)resultP)[0] = _prod64 /* & 0xFFFF */;
+_carry = _prod64 >> 16;
+resultP += 2;
+_l -= 2;
+}
+if (_l > 0) {
+UINT64 _prod64;
+_prod64 = *digitP++ * _v + _carry;
+*resultP++ = _prod64 /* & 0xFF */;
+_carry = _prod64 >> 8;
+_l--;
+}
+}
 #   else /* no INT64 type */
-	if (_v <= 0xFFFF) {
+if (_v <= 0xFFFF) {
-	    /* can do it short-wise
+/* can do it short-wise
-	     *
+*
-	     * max: 0xFFFF * 0xFFFF -> 0xFFFE.0001
+* max: 0xFFFF * 0xFFFF -> 0xFFFE.0001
-	     * + maxCarry (0xFFFF)  -> 0xFFFF.0000
+* + maxCarry (0xFFFF)  -> 0xFFFF.0000
-	     */
+*/
-	    while (_l > 1) {
+while (_l > 1) {
-		_prod = ((unsigned short *)digitP)[0] * _v + _carry;
+_prod = ((unsigned short *)digitP)[0] * _v + _carry;
-		((unsigned short *)resultP)[0] = _prod /* & 0xFFFF */;
+((unsigned short *)resultP)[0] = _prod /* & 0xFFFF */;
-		_carry = _prod >> 16;
+_carry = _prod >> 16;
-		digitP += 2;
+digitP += 2;
-		resultP += 2;
+resultP += 2;
-		_l -= 2;
+_l -= 2;
-	    }
+}
-	}
+}
 #   endif /* no INT64 */
 #  endif /* not WIN32-i386 */
 # endif /* not GNU-i386 */
 #else /* not LSB_FIRST */
 # ifdef __mips__
 #  define LOAD_WORD_WISE
 /* no, STORE_WORD_WISE makes it slower */
 # endif
-	if (_v <= 0xFFFF) {
+if (_v <= 0xFFFF) {
-	    /* can do it short-wise
+/* can do it short-wise
-	     *
+*
-	     * max: 0xFFFF * 0xFFFF -> 0xFFFE.0001
+* max: 0xFFFF * 0xFFFF -> 0xFFFE.0001
-	     * + maxCarry (0xFFFF)  -> 0xFFFF.0000
+* + maxCarry (0xFFFF)  -> 0xFFFF.0000
-	     */
+*/
-	    while (_l > 1) {
+while (_l > 1) {
-		unsigned int t;
+unsigned int t;
 #if defined(LOAD_WORD_WISE)
-		/* better fetch short-wise */
+/* better fetch short-wise */
-		t = ((unsigned short *)digitP)[0];
+t = ((unsigned short *)digitP)[0];
-		digitP += 2;
+digitP += 2;
-		t = ((t >> 8) | (t << 8)) & 0xFFFF;
+t = ((t >> 8) | (t << 8)) & 0xFFFF;
 #else
-		t = (digitP[1]<<8) + digitP[0];
+t = (digitP[1]<<8) + digitP[0];
-		digitP += 2;
+digitP += 2;
 #endif
-		_prod = t * _v + _carry;
+_prod = t * _v + _carry;
-		_carry = _prod >> 16;
+_carry = _prod >> 16;
 #if defined(STORE_WORD_WISE)
-		/* better store short-wise */
+/* better store short-wise */
-		_prod = ((_prod >> 8) | (_prod << 8)) & 0xFFFF;
+_prod = ((_prod >> 8) | (_prod << 8)) & 0xFFFF;
-		((unsigned short *)resultP)[0] = _prod;
+((unsigned short *)resultP)[0] = _prod;
 #else
-		resultP[0] = _prod /* & 0xFF */;
+resultP[0] = _prod /* & 0xFF */;
-		resultP[1] = (_prod>>8) /* & 0xFF */;
+resultP[1] = (_prod>>8) /* & 0xFF */;
 #endif
-		resultP += 2;
+resultP += 2;
-		_l -= 2;
+_l -= 2;
-	    }
+}
-	}
+}
 #endif /* LSB_FIRST */
-	/*
+/*
-	 * rest is done byte-wise
+* rest is done byte-wise
-	 */
+*/
-	while (_l > 0) {
+while (_l > 0) {
-	    _prod = *digitP++ * _v + _carry;
+_prod = *digitP++ * _v + _carry;
-	    *resultP++ = _prod /* & 0xFF */;
+*resultP++ = _prod /* & 0xFF */;
-	    _carry = _prod >> 8;
+_carry = _prod >> 8;
-	    _l--;
+_l--;
-	}
+}
-	_l = __intVal(lResult) - __intVal(len);
+_l = __intVal(lResult) - __intVal(len);
-	/*
+/*
-	 * remaining carry
+* remaining carry
-	 */
+*/
-	while (_carry) {
+while (_carry) {
-	    *resultP++ = _carry /* & 0xFF */;
+*resultP++ = _carry /* & 0xFF */;
-	    _carry >>= 8;
+_carry >>= 8;
-	    _l--;
+_l--;
-	}
+}
-	/*
+/*
-	 * remaining zeros
+* remaining zeros
-	 */
+*/
-	while (_l--) {
+while (_l--) {
-	    *resultP++ = 0;
+*resultP++ = 0;
-	}
+}
-	/*
+/*
-	 * need compress ?
+* need compress ?
-	 */
+*/
-	if (resultP[-1]) {
+if (resultP[-1]) {
-	    /*
+/*
-	     * no
+* no
-	     */
+*/
-	    RETURN(result);
+RETURN(result);
-	}
+}
-	ok = true;
+ok = true;
 }
 %}.
 "
 fall back - normally not reached
 (could make it a primitive-failure as well)
 "
 ok ifFalse:[
-	carry := 0.
+carry := 0.
-	1 to:len do:[:i |
+1 to:len do:[:i |
-	    prod := (digitByteArray basicAt:i) * val + carry.
+prod := (digitByteArray basicAt:i) * val + carry.
-	    resultDigitByteArray basicAt:i put:(prod bitAnd:16rFF).
+resultDigitByteArray basicAt:i put:(prod bitAnd:16rFF).
-	    carry := prod bitShift:-8.
+carry := prod bitShift:-8.
-	].
+].
-	[carry ~~ 0] whileTrue:[
+[carry ~~ 0] whileTrue:[
-	    len := len + 1.
+len := len + 1.
-	    resultDigitByteArray basicAt:len put:(carry bitAnd:16rFF).
+resultDigitByteArray basicAt:len put:(carry bitAnd:16rFF).
-	    carry := carry bitShift:-8
+carry := carry bitShift:-8
-	].
+].
-	[len < lResult] whileTrue:[
+[len < lResult] whileTrue:[
-	    len := len + 1.
+len := len + 1.
-	    resultDigitByteArray basicAt:len put:0
+resultDigitByteArray basicAt:len put:0
-	]
+]
 ].
 ^ result compressed
 !
 sumFromInteger:anInteger
 "sent, when anInteger does not know how to add the receiver.
 Return the sum of the receiver and the argument, (which must be a SmallInteger)"
 anInteger > 0 ifTrue:[
-	sign > 0 ifTrue:[
+sign > 0 ifTrue:[
-	    ^ self absFastPlus:anInteger sign:1
+^ self absFastPlus:anInteger sign:1
-	].
+].
-	^ self absFastMinus:anInteger sign:-1
+^ self absFastMinus:anInteger sign:-1
 ].
 anInteger == 0 ifTrue:[
-	^ self
+^ self
 ].
 sign > 0 ifTrue:[
-	^ self absFastMinus:anInteger sign:1
+^ self absFastMinus:anInteger sign:1
 ].
 ^ self absFastPlus:anInteger sign:-1
 "
 (dividend absSubtract: divisor) ifFalse:[ "result == 0"
 ^ Array with:quo compressed with:0
 ].
 ].
 shift := shift - 1.
-divisor div2.
+divisor := divisor div2.
 ].
 ^ Array with:quo compressed with:dividend compressed
 "
 Time millisecondsToRun:[ 10000 timesRepeat:[  16000000000 absDivMod:4000000000] ]
 d2   "{ Class: SmallInteger }"
 otherDigitByteArray |
 %{  /* NOCONTEXT */
 if (__isLargeInteger(aLargeInteger)) {
-	OBJ _digitByteArray = __INST(digitByteArray);
+OBJ _digitByteArray = __INST(digitByteArray);
-	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-	if (__isByteArray(_digitByteArray)
+if (__isByteArray(_digitByteArray)
-	 && __isByteArray(_otherDigitByteArray)) {
+&& __isByteArray(_otherDigitByteArray)) {
-	    INT _myLen = __byteArraySize(_digitByteArray);
+INT _myLen = __byteArraySize(_digitByteArray);
-	    INT _otherLen = __byteArraySize(_otherDigitByteArray);
+INT _otherLen = __byteArraySize(_otherDigitByteArray);
-	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-	    unsigned char *_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+unsigned char *_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-	    if (_myLen == _otherLen) {
+if (_myLen == _otherLen) {
 tryAgain:
-		while (_myLen >= (sizeof(INT)*4)) {
+while (_myLen >= (sizeof(INT)*4)) {
-		    if ( ((unsigned INT *)_myDigits)[0] != ((unsigned INT *)_otherDigits)[0]) {
+if ( ((unsigned INT *)_myDigits)[0] != ((unsigned INT *)_otherDigits)[0]) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    if ( ((unsigned INT *)_myDigits)[1] != ((unsigned INT *)_otherDigits)[1]) {
+if ( ((unsigned INT *)_myDigits)[1] != ((unsigned INT *)_otherDigits)[1]) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    if ( ((unsigned INT *)_myDigits)[2] != ((unsigned INT *)_otherDigits)[2]) {
+if ( ((unsigned INT *)_myDigits)[2] != ((unsigned INT *)_otherDigits)[2]) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    if ( ((unsigned INT *)_myDigits)[3] != ((unsigned INT *)_otherDigits)[3]) {
+if ( ((unsigned INT *)_myDigits)[3] != ((unsigned INT *)_otherDigits)[3]) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    _myDigits += sizeof(INT)*4;
+_myDigits += sizeof(INT)*4;
-		    _otherDigits += sizeof(INT)*4;
+_otherDigits += sizeof(INT)*4;
-		    _myLen -= sizeof(INT)*4;
+_myLen -= sizeof(INT)*4;
-		}
+}
-		while (_myLen >= (sizeof(INT))) {
+while (_myLen >= (sizeof(INT))) {
-		    if ( *(unsigned INT *)_myDigits != *(unsigned INT *)_otherDigits) {
+if ( *(unsigned INT *)_myDigits != *(unsigned INT *)_otherDigits) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    _myDigits += sizeof(INT);
+_myDigits += sizeof(INT);
-		    _otherDigits += sizeof(INT);
+_otherDigits += sizeof(INT);
-		    _myLen -= sizeof(INT);
+_myLen -= sizeof(INT);
-		}
+}
-		while (_myLen > 0) {
+while (_myLen > 0) {
-		    if ( *_myDigits != *_otherDigits) {
+if ( *_myDigits != *_otherDigits) {
-			RETURN(false);
+RETURN(false);
-		    }
+}
-		    _myDigits++;
+_myDigits++;
-		    _otherDigits++;
+_otherDigits++;
-		    _myLen--;
+_myLen--;
-		}
+}
-		RETURN(true);
+RETURN(true);
-	    }
+}
-	    /* care for unnormalized ints */
+/* care for unnormalized ints */
-	    while ((_myLen > 0) && (_myDigits[_myLen-1] == 0)) _myLen--;
+while ((_myLen > 0) && (_myDigits[_myLen-1] == 0)) _myLen--;
-	    while ((_otherLen > 0) && (_otherDigits[_otherLen-1] == 0)) _otherLen--;
+while ((_otherLen > 0) && (_otherDigits[_otherLen-1] == 0)) _otherLen--;
-	    if (_myLen == _otherLen) goto tryAgain;
+if (_myLen == _otherLen) goto tryAgain;
-	    RETURN(false);
+RETURN(false);
-	}
+}
 }
 %}.
 len1 := digitByteArray size.
 otherDigitByteArray := aLargeInteger digitBytes.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [(digitByteArray basicAt:len1) == 0] whileTrue:[
-	len1 := len1 - 1
+len1 := len1 - 1
 ].
 [(otherDigitByteArray basicAt:len2) == 0] whileTrue:[
-	len2 := len2 - 1
+len2 := len2 - 1
 ].
 (len1 ~~ len2) ifTrue:[^ false].
 [len1 > 0] whileTrue:[
-	d1 := digitByteArray basicAt:len1.
+d1 := digitByteArray basicAt:len1.
-	d2 := otherDigitByteArray basicAt:len1.
+d2 := otherDigitByteArray basicAt:len1.
-	(d1 ~~ d2) ifTrue:[^ false].
+(d1 ~~ d2) ifTrue:[^ false].
-	len1 := len1 - 1
+len1 := len1 - 1
 ].
 ^ true
 "Modified: / 8.5.1999 / 18:37:02 / cg"
 !
 count    "{ Class: SmallInteger }"
 newDigitByteArray result
 ok|
 aPositiveSmallInteger == 0 ifTrue:[
-	^ ZeroDivide raiseRequestWith:thisContext
+^ ZeroDivide raiseRequestWith:thisContext
 ].
 "This cannot happen (if always normalized)
 self < aPositiveSmallInteger ifTrue:[
-	^ Array with:0 with:self
+^ Array with:0 with:self
 ].
 "
 count := digitByteArray size.
 result := self class basicNew numberOfDigits:count.
 newDigitByteArray := result digitBytes.
 __digits = __INST(digitByteArray);
 if (__isByteArray(__digits)
 && __isByteArray(newDigitByteArray)
 && __bothSmallInteger(count, aPositiveSmallInteger)) {
-	unsigned INT rest = 0;
+unsigned INT rest = 0;
-	int index = __intVal(count);
+int index = __intVal(count);
-	int index0;
+int index0;
-	unsigned INT divisor = __intVal(aPositiveSmallInteger);
+unsigned INT divisor = __intVal(aPositiveSmallInteger);
-	unsigned char *digitBytes = __ByteArrayInstPtr(__digits)->ba_element;
+unsigned char *digitBytes = __ByteArrayInstPtr(__digits)->ba_element;
-	unsigned char *resultBytes = __ByteArrayInstPtr(newDigitByteArray)->ba_element;
+unsigned char *resultBytes = __ByteArrayInstPtr(newDigitByteArray)->ba_element;
-	index0 = index - 1;
+index0 = index - 1;
 # if (__POINTER_SIZE__ == 8)
-	if (sizeof(int) == 4) {
+if (sizeof(int) == 4) {
-	    /*
+/*
-	     * divide int-wise
+* divide int-wise
-	     */
+*/
-	    if (divisor <= 0xFFFFFFFF) {
+if (divisor <= 0xFFFFFFFF) {
-		if ((index & 3) == 0) { /* even number of int32's */
+if ((index & 3) == 0) { /* even number of int32's */
-		    while (index > 3) {
+while (index > 3) {
-			unsigned INT t;
+unsigned INT t;
-			unsigned INT div;
+unsigned INT div;
-			index -= 4;
+index -= 4;
 # if defined(__LSBFIRST__)
-			t = *((unsigned int *)(&digitBytes[index]));
+t = *((unsigned int *)(&digitBytes[index]));
 # else
-			t = digitBytes[index+3];
+t = digitBytes[index+3];
-			t = (t << 8) | digitBytes[index+2];
+t = (t << 8) | digitBytes[index+2];
-			t = (t << 8) | digitBytes[index+1];
+t = (t << 8) | digitBytes[index+1];
-			t = (t << 8) | digitBytes[index];
+t = (t << 8) | digitBytes[index];
 # endif
-			t = t | (rest << 32);
+t = t | (rest << 32);
-			div = t / divisor;
+div = t / divisor;
-			rest = t % divisor;
+rest = t % divisor;
 # if defined(__LSBFIRST__)
-			*((unsigned int *)(&resultBytes[index])) = (div & 0xFFFFFFFF);
+*((unsigned int *)(&resultBytes[index])) = (div & 0xFFFFFFFF);
 # else
-			resultBytes[index+3] = div >> 24;
+resultBytes[index+3] = div >> 24;
-			resultBytes[index+2] = div >> 16;
+resultBytes[index+2] = div >> 16;
-			resultBytes[index+1] = div >> 8;
+resultBytes[index+1] = div >> 8;
-			resultBytes[index] = div /* & 0xFF */;
+resultBytes[index] = div /* & 0xFF */;
 # endif
-		    }
+}
-		}
+}
-	    }
+}
-	}
+}
 #endif
-	/*
+/*
-	 * divide short-wise
+* divide short-wise
-	 */
+*/
-	if (divisor <= 0xFFFF) {
+if (divisor <= 0xFFFF) {
-	    if ((index & 1) == 0) { /* even number of bytes */
+if ((index & 1) == 0) { /* even number of bytes */
-		while (index > 1) {
+while (index > 1) {
-		    unsigned INT t;
+unsigned INT t;
-		    unsigned INT div;
+unsigned INT div;
-		    index -= 2;
+index -= 2;
 #if defined(__LSBFIRST__)
-		    t = *((unsigned short *)(&digitBytes[index]));
+t = *((unsigned short *)(&digitBytes[index]));
 #else
-		    t = digitBytes[index+1];
+t = digitBytes[index+1];
-		    t = (t << 8) | digitBytes[index];
+t = (t << 8) | digitBytes[index];
 #endif
-		    t = t | (rest << 16);
+t = t | (rest << 16);
-		    div = t / divisor;
+div = t / divisor;
-		    rest = t % divisor;
+rest = t % divisor;
 #if defined(__LSBFIRST__)
-		    *((unsigned short *)(&resultBytes[index])) = (div & 0xFFFF);
+*((unsigned short *)(&resultBytes[index])) = (div & 0xFFFF);
 #else
-		    resultBytes[index+1] = div >> 8;
+resultBytes[index+1] = div >> 8;
-		    resultBytes[index] = div /* & 0xFF */;
+resultBytes[index] = div /* & 0xFF */;
 #endif
-		}
+}
-	    }
+}
-	}
+}
-	while (index > 0) {
+while (index > 0) {
-	    unsigned INT t;
+unsigned INT t;
-	    index--;
+index--;
-	    t = digitBytes[index];
+t = digitBytes[index];
-	    t = t | (rest << 8);
+t = t | (rest << 8);
-	    resultBytes[index] = t / divisor;
+resultBytes[index] = t / divisor;
-	    rest = t % divisor;
+rest = t % divisor;
-	}
+}
-	prevRest = __mkSmallInteger(rest);
+prevRest = __mkSmallInteger(rest);
-	/*
+/*
-	 * no need to normalize ?
+* no need to normalize ?
-	 */
+*/
-	index = index0;
+index = index0;
-	while ((index >= sizeof(INT)) && (resultBytes[index]==0)) {
+while ((index >= sizeof(INT)) && (resultBytes[index]==0)) {
-	    index--;
+index--;
-	}
+}
-	if (index == index0) {
+if (index == index0) {
-	    if (index > sizeof(INT)) {
+if (index > sizeof(INT)) {
-		RETURN ( __ARRAY_WITH2(result, prevRest));
+RETURN ( __ARRAY_WITH2(result, prevRest));
-	    }
+}
-	    if ((index == sizeof(INT))
+if ((index == sizeof(INT))
-	    && resultBytes[index0] >= 0x40) {
+&& resultBytes[index0] >= 0x40) {
-		RETURN ( __ARRAY_WITH2(result, prevRest));
+RETURN ( __ARRAY_WITH2(result, prevRest));
-	    }
+}
-	}
+}
-	/*
+/*
-	 * must compress
+* must compress
-	 */
+*/
-	ok = true;
+ok = true;
 }
 %}.
 "
 slow code - not normally reached
 (could also do a primitiveFailure here)
 "
 ok ifFalse:[
-	^ self absDivMod:(self class value:aPositiveSmallInteger).
+^ self absDivMod:(self class value:aPositiveSmallInteger).
 ].
 ^ Array with:(result compressed) with:prevRest
 "
 "/ the following code only works with
 "/ smallIntegers in the range _MIN_INT+255 .. _MAX_INT-255
 ((aSmallInteger < (SmallInteger minVal + 255))
 or:[aSmallInteger > (SmallInteger maxVal - 255)]) ifTrue:[
-	^ self absMinus:(self class value:aSmallInteger) sign:newSign.
+^ self absMinus:(self class value:aSmallInteger) sign:newSign.
 ].
 len := digitByteArray size.
 rsltLen := len "+ 1".
 borrow := aSmallInteger abs.
 %{
 if (__isByteArray(__INST(digitByteArray))
 && __isByteArray(resultDigitByteArray)) {
-	unsigned INT __borrow = __intVal(borrow);
+unsigned INT __borrow = __intVal(borrow);
-	INT __diff;
+INT __diff;
-	int __index = 1;
+int __index = 1;
-	int __len = __intVal(len);
+int __len = __intVal(len);
-	unsigned char *__digitP = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
+unsigned char *__digitP = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
-	unsigned char *__resultP = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
+unsigned char *__resultP = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
-	int __len3;
+int __len3;
 #if defined(__LSBFIRST__)
 # if (__POINTER_SIZE__ == 8)
-	/*
+/*
-	 * subtract int-wise
+* subtract int-wise
-	 */
+*/
-	__len3 = __len - 3;
+__len3 = __len - 3;
-	while (__index < __len3) {
+while (__index < __len3) {
-	    /* do not make this into one expression - ask cg why */
+/* do not make this into one expression - ask cg why */
-	    __diff = ((unsigned int *)(__digitP + __index-1))[0];
+__diff = ((unsigned int *)(__digitP + __index-1))[0];
-	    __diff -= (__borrow & 0xFFFFFFFFL);
+__diff -= (__borrow & 0xFFFFFFFFL);
-	    __borrow >>= 32;
+__borrow >>= 32;
-	    if (__diff < 0) {
+if (__diff < 0) {
-		/* __diff += 0x100000000; */
+/* __diff += 0x100000000; */
-		__borrow++;
+__borrow++;
-	    }
+}
-	    ((unsigned int *)(__resultP+__index-1))[0] = __diff;
+((unsigned int *)(__resultP+__index-1))[0] = __diff;
-	    __index += 4;
+__index += 4;
-	}
+}
 # endif
-	/*
+/*
-	 * subtract short-wise
+* subtract short-wise
-	 */
+*/
-	while (__index < __len) {
+while (__index < __len) {
-	    /* do not make this into one expression - ask cg why */
+/* do not make this into one expression - ask cg why */
-	    __diff = ((unsigned short *)(__digitP+__index-1))[0];
+__diff = ((unsigned short *)(__digitP+__index-1))[0];
-	    __diff -= (__borrow & 0xFFFF);
+__diff -= (__borrow & 0xFFFF);
-	    __borrow >>= 16;
+__borrow >>= 16;
-	    if (__diff < 0) {
+if (__diff < 0) {
-		/* __diff += 0x10000; */
+/* __diff += 0x10000; */
-		__borrow++;
+__borrow++;
-	    } else {
+} else {
-		if (__borrow == 0) {
+if (__borrow == 0) {
-		    ((unsigned short *)(__resultP+__index-1))[0] = __diff;
+((unsigned short *)(__resultP+__index-1))[0] = __diff;
-		    __index += 2;
+__index += 2;
-		    /* nothing more to subtract .. */
+/* nothing more to subtract .. */
-		    while (__index < __len) {
+while (__index < __len) {
-			((unsigned short *)(__resultP+__index-1))[0] = ((unsigned short *)(__digitP+__index-1))[0];
+((unsigned short *)(__resultP+__index-1))[0] = ((unsigned short *)(__digitP+__index-1))[0];
-			__index += 2;
+__index += 2;
-		    }
+}
-		    if (__index <= __len) {
+if (__index <= __len) {
-			__resultP[__index-1] = __digitP[__index-1];
+__resultP[__index-1] = __digitP[__index-1];
-		    }
+}
-		    break;
+break;
-		}
+}
-	    }
+}
-	    ((unsigned short *)(__resultP+__index-1))[0] = __diff;
+((unsigned short *)(__resultP+__index-1))[0] = __diff;
-	    __index += 2;
+__index += 2;
-	}
+}
 #endif
-	/*
+/*
-	 * subtract byte-wise
+* subtract byte-wise
-	 */
+*/
-	while (__index <= __len) {
+while (__index <= __len) {
-	    __diff = __digitP[__index-1];
+__diff = __digitP[__index-1];
-	    __diff -= (__borrow & 0xFF);
+__diff -= (__borrow & 0xFF);
-	    __borrow >>= 8;
+__borrow >>= 8;
-	    if (__diff < 0) {
+if (__diff < 0) {
-		/* __diff += 0x100; */
+/* __diff += 0x100; */
-		__borrow++;
+__borrow++;
-	    } else {
+} else {
-		if (__borrow == 0) {
+if (__borrow == 0) {
-		    __resultP[__index-1] = __diff;
+__resultP[__index-1] = __diff;
-		    __index++;
+__index++;
-		    /* nothing more to subtract .. */
+/* nothing more to subtract .. */
-		    while (__index <= __len) {
+while (__index <= __len) {
-			__resultP[__index-1] = __digitP[__index-1];
+__resultP[__index-1] = __digitP[__index-1];
-			__index++;
+__index++;
-		    }
+}
-		    break;
+break;
-		}
+}
-	    }
+}
-	    __resultP[__index-1] = __diff;
+__resultP[__index-1] = __diff;
-	    __index++;
+__index++;
-	}
+}
-	lastDigit = __mkSmallInteger( __resultP[__index-1-1] );
+lastDigit = __mkSmallInteger( __resultP[__index-1-1] );
-	ok = true;
+ok = true;
 }
 %}.
 ok == true ifFalse:[        "/ cannot happen
-	index := 1.
+index := 1.
-	[borrow ~~ 0] whileTrue:[
+[borrow ~~ 0] whileTrue:[
-	    (index <= len) ifTrue:[
+(index <= len) ifTrue:[
-		diff := (digitByteArray basicAt:index) - (borrow bitAnd:16rFF).
+diff := (digitByteArray basicAt:index) - (borrow bitAnd:16rFF).
-		borrow := borrow bitShift:-8.
+borrow := borrow bitShift:-8.
-		diff < 0 ifTrue:[
+diff < 0 ifTrue:[
-		    diff := diff + 256.
+diff := diff + 256.
-		    borrow := borrow + 1.
+borrow := borrow + 1.
-		]
+]
-	    ] ifFalse:[
+] ifFalse:[
-		diff := borrow bitAnd:255.
+diff := borrow bitAnd:255.
-		borrow := borrow bitShift:-8.
+borrow := borrow bitShift:-8.
-	    ].
+].
-	    resultDigitByteArray basicAt:index put:(lastDigit := diff).
+resultDigitByteArray basicAt:index put:(lastDigit := diff).
-	    index := index + 1
+index := index + 1
-	].
+].
-	[index <= len] whileTrue:[
+[index <= len] whileTrue:[
-	    resultDigitByteArray basicAt:index put:(lastDigit := digitByteArray basicAt:index).
+resultDigitByteArray basicAt:index put:(lastDigit := digitByteArray basicAt:index).
-	    index := index + 1
+index := index + 1
-	].
+].
-	(index <= rsltLen) ifTrue:[
+(index <= rsltLen) ifTrue:[
-	    lastDigit := 0.
+lastDigit := 0.
-	]
+]
 ].
 (lastDigit == 0 or:[rsltLen <= SmallInteger maxBytes]) ifTrue:[
-	^ result compressed.
+^ result compressed.
 ].
 ^ result
 "
 12345678900000000000 absFastMinus:1 sign:1
 "/ the following code only works with
 "/ smallIntegers in the range _MIN_INT+255 .. _MAX_INT-255
 ((aSmallInteger < (SmallInteger minVal + 255))
 or:[aSmallInteger > (SmallInteger maxVal - 255)]) ifTrue:[
-	^ self absPlus:(self class value:aSmallInteger) sign:newSign.
+^ self absPlus:(self class value:aSmallInteger) sign:newSign.
 ].
 len := rsltLen := digitByteArray size.
 "/
 "/ there can only be an overflow from the high byte,
 "/ if it is 255 (since the other number is definitely smaller)
 "/
 (digitByteArray at:len) == 16rFF ifTrue:[
-	rsltLen := len + 1.
+rsltLen := len + 1.
 ] ifFalse:[
-	"/ or the argument has something in the high byte ..
+"/ or the argument has something in the high byte ..
 %{
 #if __POINTER_SIZE__ == 8
-	if (__intVal(aSmallInteger) & 0xFF00000000000000L) {
+if (__intVal(aSmallInteger) & 0xFF00000000000000L) {
-	    rsltLen = __mkSmallInteger(__intVal(len) + 1);
+rsltLen = __mkSmallInteger(__intVal(len) + 1);
-	}
+}
 #else
-	if (__intVal(aSmallInteger) & 0xFF000000) {
+if (__intVal(aSmallInteger) & 0xFF000000) {
-	    rsltLen = __mkSmallInteger(__intVal(len) + 1);
+rsltLen = __mkSmallInteger(__intVal(len) + 1);
-	}
+}
 #endif
 %}
 ].
 result := self class basicNew numberOfDigits:rsltLen sign:newSign.
 %{
 if (__isByteArray(__INST(digitByteArray))
 && __isByteArray(resultDigitByteArray)
 && __isSmallInteger(aSmallInteger)) {
-	/* carry is NOT unsigned (see negation below) */
+/* carry is NOT unsigned (see negation below) */
-	INT __carry = __intVal(aSmallInteger);
+INT __carry = __intVal(aSmallInteger);
-	int __index = 1;
+int __index = 1;
-	int __len = __intVal(len);
+int __len = __intVal(len);
-	unsigned char *__src = (unsigned char *)(__ByteArrayInstPtr(__INST(digitByteArray))->ba_element);
+unsigned char *__src = (unsigned char *)(__ByteArrayInstPtr(__INST(digitByteArray))->ba_element);
-	unsigned char *__dst = (unsigned char *)(__ByteArrayInstPtr(resultDigitByteArray)->ba_element);
+unsigned char *__dst = (unsigned char *)(__ByteArrayInstPtr(resultDigitByteArray)->ba_element);
-	INT __ptrDelta = __dst - __src;
+INT __ptrDelta = __dst - __src;
-	unsigned char *__srcLast = __src + __len - 1;
+unsigned char *__srcLast = __src + __len - 1;
-	int __rsltLen = __intVal(rsltLen);
+int __rsltLen = __intVal(rsltLen);
-	if (__carry < 0) {
+if (__carry < 0) {
-	    __carry = -__carry;
+__carry = -__carry;
-	}
+}
 #if defined(__LSBFIRST__)
 # if defined(__i386__) && defined(__GNUC__) && (__POINTER_SIZE__ == 4)
 #  if 0 /* NOTICE - the code below is 20% slower ... - why */
-	/*
+/*
-	 * add long-wise
+* add long-wise
-	 */
+*/
-	asm("  jecxz nothingToDo                                      \n\
+asm("  jecxz nothingToDo                                      \n\
-	       movl  %%eax, %%esi      /* __src input */              \n\
+movl  %%eax, %%esi      /* __src input */              \n\
-	       movl  %%ebx, %%edi      /* __dst input */              \n\
+movl  %%ebx, %%edi      /* __dst input */              \n\
-								      \n\
+\n\
-	       /* the first 4-byte int */                             \n\
+/* the first 4-byte int */                             \n\
-	       lodsl                   /* fetch */                    \n\
+lodsl                   /* fetch */                    \n\
-	       addl  %%edx, %%eax      /* add */                      \n\
+addl  %%edx, %%eax      /* add */                      \n\
-	       stosl                   /* store */                    \n\
+stosl                   /* store */                    \n\
-	       leal  -1(%%ecx),%%ecx   /* do not clobber carry */     \n\
+leal  -1(%%ecx),%%ecx   /* do not clobber carry */     \n\
-	       jecxz doneLoop          /* any more ? */               \n\
+jecxz doneLoop          /* any more ? */               \n\
-	       /* remaining 4-byte ints */                            \n\
+/* remaining 4-byte ints */                            \n\
-	       jmp   addLoop                                          \n\
+jmp   addLoop                                          \n\
-								      \n\
+\n\
-	       .align 8                                               \n\
+.align 8                                               \n\
-	     addLoop:                                                 \n\
+addLoop:                                                 \n\
-	       movl  0(%%esi), %%ebx   /* fetch  */                   \n\
+movl  0(%%esi), %%ebx   /* fetch  */                   \n\
-	       jnc   copyLoop2                                        \n\
+jnc   copyLoop2                                        \n\
-	       movl  $0, %%eax                                        \n\
+movl  $0, %%eax                                        \n\
-	       leal  4(%%esi), %%esi                                  \n\
+leal  4(%%esi), %%esi                                  \n\
-	       adcl  %%ebx, %%eax      /* & add carry from prev int */\n\
+adcl  %%ebx, %%eax      /* & add carry from prev int */\n\
-	       leal  8(%%edi), %%edi                                  \n\
+leal  8(%%edi), %%edi                                  \n\
-	       movl  %%eax, -8(%%edi)  /* store */                    \n\
+movl  %%eax, -8(%%edi)  /* store */                    \n\
-	       leal  -1(%%ecx),%%ecx   /* do not clobber carry */     \n\
+leal  -1(%%ecx),%%ecx   /* do not clobber carry */     \n\
-	       jecxz doneLoop          /* any more ? */               \n\
+jecxz doneLoop          /* any more ? */               \n\
-								      \n\
+\n\
-	       movl  0(%%esi), %%ebx   /* fetch  */                   \n\
+movl  0(%%esi), %%ebx   /* fetch  */                   \n\
-	       movl  $0, %%eax                                        \n\
+movl  $0, %%eax                                        \n\
-	       leal  4(%%esi), %%esi                                  \
+leal  4(%%esi), %%esi                                  \
-	       adcl  %%ebx, %%eax      /* & add carry from prev int */\n\
+adcl  %%ebx, %%eax      /* & add carry from prev int */\n\
-	       movl  %%eax, -4(%%edi)  /* store */                    \n\
+movl  %%eax, -4(%%edi)  /* store */                    \n\
-								      \n\
+\n\
-	       loop  addLoop                                          \n\
+loop  addLoop                                          \n\
-	       jmp   doneLoop                                         \n\
+jmp   doneLoop                                         \n\
-								      \n\
+\n\
-	       .align 8                                               \n\
+.align 8                                               \n\
-	     copyLoop:                                                \n\
+copyLoop:                                                \n\
-	       movl  0(%%esi), %%ebx                                  \n\
+movl  0(%%esi), %%ebx                                  \n\
-	     copyLoop2:                                               \n\
+copyLoop2:                                               \n\
-	       add   $4, %%esi                                        \n\
+add   $4, %%esi                                        \n\
-	       add   $4, %%edi                                        \n\
+add   $4, %%edi                                        \n\
-	       movl  %%ebx, -4(%%edi)                                 \n\
+movl  %%ebx, -4(%%edi)                                 \n\
-	       loop  copyLoop                                         \n\
+loop  copyLoop                                         \n\
-								      \n\
+\n\
-	     doneLoop:                                                \n\
+doneLoop:                                                \n\
-	       movl  $0, %%edx         /* do not clobber carry (xorl clears it) */   \n\
+movl  $0, %%edx         /* do not clobber carry (xorl clears it) */   \n\
-	       adcl  $0, %%edx                                        \n\
+adcl  $0, %%edx                                        \n\
-	       movl  %%esi, %%eax      /* __src output */             \n\
+movl  %%esi, %%eax      /* __src output */             \n\
-	     nothingToDo:                                             \n\
+nothingToDo:                                             \n\
-	    " : "=d"  ((unsigned long)(__carry)),
+" : "=d"  ((unsigned long)(__carry)),
-		"=a"  (__src)
+"=a"  (__src)
-	      : "1"   (__src),
+: "1"   (__src),
-		"b"   (__dst),
+"b"   (__dst),
-		"c"   (__len / 4),
+"c"   (__len / 4),
-		"0"   (__carry)
+"0"   (__carry)
-	      : "esi", "edi");
+: "esi", "edi");
 #  else
-	{
+{
-	    unsigned char *__srcLastX;
+unsigned char *__srcLastX;
-	    __srcLastX = __srcLast - 3 - 4;
+__srcLastX = __srcLast - 3 - 4;
-	    while (__src <= __srcLastX) {
+while (__src <= __srcLastX) {
-		unsigned int __sum, __sum2;
+unsigned int __sum, __sum2;
-		unsigned __digit1, __digit2;
+unsigned __digit1, __digit2;
-		__digit1 = ((unsigned *)__src)[0];
+__digit1 = ((unsigned *)__src)[0];
-		__digit2 = ((unsigned *)__src)[1];
+__digit2 = ((unsigned *)__src)[1];
-		asm ("addl %%edx,%%ecx          \n\
+asm ("addl %%edx,%%ecx          \n\
-		      adcl $0, %%eax            \n\
+adcl $0, %%eax            \n\
-		      movl $0, %%edx            \n\
+movl $0, %%edx            \n\
-		      adcl $0, %%edx"
+adcl $0, %%edx"
-			: "=d"  ((unsigned long)(__carry)),
+: "=d"  ((unsigned long)(__carry)),
-			  "=c"  ((unsigned long)(__sum)),
+"=c"  ((unsigned long)(__sum)),
-			  "=a"  ((unsigned long)(__sum2))
+"=a"  ((unsigned long)(__sum2))
-			: "0"   ((unsigned long)(__carry)),
+: "0"   ((unsigned long)(__carry)),
-			  "1"   (__digit1),
+"1"   (__digit1),
-			  "2"   (__digit2));
+"2"   (__digit2));
-		((unsigned int *)(__src + __ptrDelta))[0] = __sum;
+((unsigned int *)(__src + __ptrDelta))[0] = __sum;
-		((unsigned int *)(__src + __ptrDelta))[1] = __sum2;
+((unsigned int *)(__src + __ptrDelta))[1] = __sum2;
-		__src += 8;
+__src += 8;
-		if (__carry == 0) {
+if (__carry == 0) {
-		    while (__src <= __srcLastX) {
+while (__src <= __srcLastX) {
-			/* copy over words */
+/* copy over words */
-			((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
+((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
-			((unsigned int *)(__src + __ptrDelta))[1] = ((unsigned int *)__src)[1];
+((unsigned int *)(__src + __ptrDelta))[1] = ((unsigned int *)__src)[1];
-			__src += 8;
+__src += 8;
-		    }
+}
-		    while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-			/* copy over bytes */
+/* copy over bytes */
-			__src[__ptrDelta] = __src[0];
+__src[__ptrDelta] = __src[0];
-			__src ++;
+__src ++;
-		    }
+}
-		    goto doneSource;
+goto doneSource;
-		}
+}
-	    }
+}
-	    __srcLastX = __srcLastX + 4;
+__srcLastX = __srcLastX + 4;
-	    if (__src <= __srcLastX) {
+if (__src <= __srcLastX) {
-		unsigned int __sum, __digit;
+unsigned int __sum, __digit;
-		__digit = ((unsigned *)__src)[0];
+__digit = ((unsigned *)__src)[0];
-		asm ("addl %%eax,%%edx  \n\
+asm ("addl %%eax,%%edx  \n\
-		      movl $0,%%eax     \n\
+movl $0,%%eax     \n\
-		      adcl $0,%%eax"
+adcl $0,%%eax"
-			: "=a"  ((unsigned long)(__carry)),
+: "=a"  ((unsigned long)(__carry)),
-			  "=d"  ((unsigned long)(__sum))
+"=d"  ((unsigned long)(__sum))
-			: "0"   ((unsigned long)(__carry)),
+: "0"   ((unsigned long)(__carry)),
-			  "1"   (__digit) );
+"1"   (__digit) );
-		((unsigned int *)(__src + __ptrDelta))[0] = __sum;
+((unsigned int *)(__src + __ptrDelta))[0] = __sum;
-		__src += 4;
+__src += 4;
-		if (__carry == 0) {
+if (__carry == 0) {
-		    while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-			/* copy over bytes */
+/* copy over bytes */
-			__src[__ptrDelta] = __src[0];
+__src[__ptrDelta] = __src[0];
-			__src ++;
+__src ++;
-		    }
+}
-		    goto doneSource;
+goto doneSource;
-		}
+}
-	    }
+}
-	}
+}
 #  endif
 # else /* not i386-GNUC */
 #  if defined(WIN32) && defined(__BORLANDC__) && defined(__i386__) && (__POINTER_SIZE__ == 4)
-	{
+{
-	    unsigned char *__srcLast4;
+unsigned char *__srcLast4;
-	    /*
+/*
-	     * add long-wise
+* add long-wise
-	     */
+*/
-	    __srcLast4 = __srcLast - 3;
+__srcLast4 = __srcLast - 3;
-	    while (__src <= __srcLast4) {
+while (__src <= __srcLast4) {
-		unsigned int __sum;
+unsigned int __sum;
-		__sum = ((unsigned int *)__src)[0];
+__sum = ((unsigned int *)__src)[0];
-		asm {
+asm {
-		      mov eax, __sum
+mov eax, __sum
-		      add eax, __carry
+add eax, __carry
-		      mov edx, 0
+mov edx, 0
-		      adc edx, 0
+adc edx, 0
-		      mov __sum, eax
+mov __sum, eax
-		      mov __carry, edx
+mov __carry, edx
-		    }
+}
-		((unsigned int *)(__src + __ptrDelta))[0] = __sum;
+((unsigned int *)(__src + __ptrDelta))[0] = __sum;
-		__src += 4;
+__src += 4;
-		if (__carry == 0) {
+if (__carry == 0) {
-		    while (__src <= __srcLast4) {
+while (__src <= __srcLast4) {
-			/* copy over words */
+/* copy over words */
-			((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
+((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
-			__src += 4;
+__src += 4;
-		    }
+}
-		    while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-			/* copy over bytes */
+/* copy over bytes */
-			__src[__ptrDelta] = __src[0];
+__src[__ptrDelta] = __src[0];
-			__src ++;
+__src ++;
-		    }
+}
-		    goto doneSource;
+goto doneSource;
-		}
+}
-	    }
+}
-	}
+}
 #  else /* not i386-WIN32 */
 #   if defined(__LSBFIRST__) && (__POINTER_SIZE__ == 8)
-	{
+{
-	    unsigned char *__srcLast4;
+unsigned char *__srcLast4;
-	    /*
+/*
-	     * add long-wise
+* add long-wise
-	     */
+*/
-	    __srcLast4 = __srcLast - 3;
+__srcLast4 = __srcLast - 3;
-	    while (__src <= __srcLast4) {
+while (__src <= __srcLast4) {
-		unsigned INT __sum;
+unsigned INT __sum;
-		__sum = ((unsigned int *)__src)[0] + __carry;
+__sum = ((unsigned int *)__src)[0] + __carry;
-		((unsigned int *)(__src + __ptrDelta))[0] = __sum /* & 0xFFFF */;
+((unsigned int *)(__src + __ptrDelta))[0] = __sum /* & 0xFFFF */;
-		__src += 4;
+__src += 4;
-		__carry = __sum >> 32;
+__carry = __sum >> 32;
-		if (__carry == 0) {
+if (__carry == 0) {
-		    while (__src <= __srcLast4) {
+while (__src <= __srcLast4) {
-			/* copy over words */
+/* copy over words */
-			((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
+((unsigned int *)(__src + __ptrDelta))[0] = ((unsigned int *)__src)[0];
-			__src += 4;
+__src += 4;
-		    }
+}
-		    while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-			/* copy over bytes */
+/* copy over bytes */
-			__src[__ptrDelta] = __src[0];
+__src[__ptrDelta] = __src[0];
-			__src ++;
+__src ++;
-		    }
+}
-		    goto doneSource;
+goto doneSource;
-		}
+}
-	    }
+}
-	}
+}
 #   endif /* LSB+64bit */
 #  endif /* __i386__ & WIN32 */
 # endif /* __i386__ & GNUC */
-	/*
+/*
-	 * add short-wise
+* add short-wise
-	 */
+*/
-	while (__src < __srcLast) {
+while (__src < __srcLast) {
-	    __carry += ((unsigned short *)__src)[0];
+__carry += ((unsigned short *)__src)[0];
-	    ((unsigned short *)(__src + __ptrDelta))[0] = __carry /* & 0xFFFF */;
+((unsigned short *)(__src + __ptrDelta))[0] = __carry /* & 0xFFFF */;
-	    __carry >>= 16;
+__carry >>= 16;
-	    __src += 2;
+__src += 2;
-	}
+}
-	/*
+/*
-	 * last (odd) byte
+* last (odd) byte
-	 */
+*/
-	if (__src <= __srcLast) {
+if (__src <= __srcLast) {
-	    __carry += __src[0];
+__carry += __src[0];
-	    __src[__ptrDelta] = __carry /* & 0xFF */;
+__src[__ptrDelta] = __carry /* & 0xFF */;
-	    __carry >>= 8;
+__carry >>= 8;
-	    __src++;
+__src++;
-	}
+}
 #else /* not __LSBFIRST__ */
-	/*
+/*
-	 * add byte-wise
+* add byte-wise
-	 */
+*/
-	while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-	    __carry += __src[0];
+__carry += __src[0];
-	    __src[__ptrDelta] = __carry /* & 0xFF */;
+__src[__ptrDelta] = __carry /* & 0xFF */;
-	    __src++;
+__src++;
-	    __carry >>= 8;
+__carry >>= 8;
-	    if (__carry == 0) {
+if (__carry == 0) {
-		while (__src <= __srcLast) {
+while (__src <= __srcLast) {
-		    /* copy over rest */
+/* copy over rest */
-		    __src[__ptrDelta] = __src[0];
+__src[__ptrDelta] = __src[0];
-		    __src++;
+__src++;
-		}
+}
-		goto doneSource;
+goto doneSource;
-	    }
+}
-	}
+}
 #endif /* __LSBFIRST__ */
 doneSource: ;
-	/*
+/*
-	 * now, at most one other byte is to be stored ...
+* now, at most one other byte is to be stored ...
-	 */
+*/
-	if (__len < __rsltLen) {
+if (__len < __rsltLen) {
-	    __src[__ptrDelta] = __carry /* & 0xFF */;
+__src[__ptrDelta] = __carry /* & 0xFF */;
-	    __src++;
+__src++;
-	}
+}
-	if (__src[__ptrDelta-1]) {      /* lastDigit */
+if (__src[__ptrDelta-1]) {      /* lastDigit */
-	    RETURN (result);
+RETURN (result);
-	}
+}
-	ok = true;
+ok = true;
 }
 %}.
 ok ~~ true ifTrue:[
-	index := 1.
+index := 1.
-	carry := aSmallInteger abs.
+carry := aSmallInteger abs.
-	[carry ~~ 0] whileTrue:[
+[carry ~~ 0] whileTrue:[
-	    (index <= len) ifTrue:[
+(index <= len) ifTrue:[
-		carry := (digitByteArray basicAt:index) + carry.
+carry := (digitByteArray basicAt:index) + carry.
-	    ].
+].
-	    resultDigitByteArray basicAt:index put:(lastDigit := carry bitAnd:16rFF).
+resultDigitByteArray basicAt:index put:(lastDigit := carry bitAnd:16rFF).
-	    carry := carry bitShift:-8.
+carry := carry bitShift:-8.
-	    index := index + 1
+index := index + 1
-	].
+].
-	(index <= rsltLen) ifTrue:[
+(index <= rsltLen) ifTrue:[
-	    [index <= len] whileTrue:[
+[index <= len] whileTrue:[
-		resultDigitByteArray basicAt:index put:(digitByteArray basicAt:index).
+resultDigitByteArray basicAt:index put:(digitByteArray basicAt:index).
-		index := index + 1
+index := index + 1
-	    ].
+].
-	    lastDigit := 0.
+lastDigit := 0.
-	].
+].
-	(lastDigit ~~ 0 and:[rsltLen > SmallInteger maxBytes]) ifTrue:[
+(lastDigit ~~ 0 and:[rsltLen > SmallInteger maxBytes]) ifTrue:[
-	    ^ result
+^ result
-	].
+].
 ].
 ^ result compressed
 "Modified: 24.3.1997 / 21:32:41 / cg"
 %{  /* NOCONTEXT */
 #if defined(__LSBFIRST__)
 if (__isByteArray(__INST(digitByteArray))
 && __isLargeInteger(aLargeInteger)) {
-	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-	if (__isByteArray(_otherDigitByteArray)) {
+if (__isByteArray(_otherDigitByteArray)) {
-	    unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
+unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
-	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-	    INT _myLen = __byteArraySize(__INST(digitByteArray));
+INT _myLen = __byteArraySize(__INST(digitByteArray));
+INT _otherLen = __byteArraySize(_otherDigitByteArray);
-	    if (_myLen == __POINTER_SIZE__) {
-		INT _otherLen = __byteArraySize(_otherDigitByteArray);
+if (_myLen == __POINTER_SIZE__) {
+if (_otherLen == __POINTER_SIZE__) {
-		if (_otherLen == __POINTER_SIZE__) {
+unsigned INT _myVal = *((unsigned INT *)_myDigits);
-		    unsigned INT _myVal = *((unsigned INT *)_myDigits);
+unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
-		    unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
+RETURN( (_myVal < _otherVal) ? true : false );
-		    RETURN( (_myVal < _otherVal) ? true : false );
+}
-		}
+}
-	    }
 # if defined(UINT64) && (__POINTER_SIZE__ != 8)
-	    if (_myLen == __POINTER_SIZE__) {
+if (_myLen == __POINTER_SIZE__) {
-		INT _otherLen = __byteArraySize(_otherDigitByteArray);
+if (_otherLen <= 8) {
+UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
-		if (_otherLen <= 8) {
+UINT64 _otherVal = *((UINT64 *)_otherDigits);
-		    UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
+RETURN( (_myVal < _otherVal) ? true : false );
-		    UINT64 _otherVal = *((UINT64 *)_otherDigits);
+}
-		    RETURN( (_myVal < _otherVal) ? true : false );
+} else {
-		}
+if (_myLen <= 8) {
-	    } else {
+if (_otherLen <= 8) {
-		if (_myLen <= 8) {
+UINT64 _myVal = (*((UINT64 *)_myDigits));
-		    INT _otherLen = __byteArraySize(_otherDigitByteArray);
+UINT64 _otherVal = *((UINT64 *)_otherDigits);
+RETURN( (_myVal < _otherVal) ? true : false );
-		    if (_otherLen <= 8) {
+}
-			UINT64 _myVal = (*((UINT64 *)_myDigits));
+if (_otherLen == __POINTER_SIZE__) {
-			UINT64 _otherVal = *((UINT64 *)_otherDigits);
+UINT64 _myVal = (*((UINT64 *)_myDigits));
-			RETURN( (_myVal < _otherVal) ? true : false );
+UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
-		    }
+RETURN( (_myVal < _otherVal) ? true : false );
-		    if (_otherLen == __POINTER_SIZE__) {
+}
-			UINT64 _myVal = (*((UINT64 *)_myDigits));
+}
-			UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
+}
-			RETURN( (_myVal < _otherVal) ? true : false );
-		    }
-		}
-	    }
 # endif /* UINT64 */
-	}
+while ((_myLen > 0) && (_myDigits[_myLen-1] == 0)) _myLen--;
+while ((_otherLen > 0) && (_otherDigits[_otherLen-1] == 0)) _otherLen--;
+if (_myLen < _otherLen) { RETURN( true ); }
+if (_myLen > _otherLen) { RETURN (false ); }
+while (_myLen-- > 0) {
+unsigned char _d1 = _myDigits[_myLen];
+unsigned char _d2 = _otherDigits[_myLen];
+if (_d1 != _d2) {
+if (_d1 < _d2) { RETURN( true ); }
+RETURN (false );
+}
+}
+RETURN (false );
+}
 }
 #endif /* LSBFIRST */
 %}.
 myLen := digitByteArray size.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [myLen > 0 and:[(digitByteArray basicAt:myLen) == 0]] whileTrue:[
-	myLen := myLen - 1
+myLen := myLen - 1
 ].
 [otherLen > 0 and:[(otherDigitByteArray basicAt:otherLen) == 0]] whileTrue:[
-	otherLen := otherLen - 1
+otherLen := otherLen - 1
 ].
 (myLen < otherLen) ifTrue:[^ true].
 (myLen > otherLen) ifTrue:[^ false].
 [myLen > 0] whileTrue:[
-	d1 := digitByteArray basicAt:myLen.
+d1 := digitByteArray basicAt:myLen.
-	d2 := otherDigitByteArray basicAt:myLen.
+d2 := otherDigitByteArray basicAt:myLen.
-	d1 == d2 ifFalse:[
+d1 == d2 ifFalse:[
-	    (d1 < d2) ifTrue:[^ true].
+(d1 < d2) ifTrue:[^ true].
-	    ^ false
+^ false
-	].
+].
-	myLen := myLen - 1
+myLen := myLen - 1
 ].
 ^ false
 "
 |a b|
 %{  /* NOCONTEXT */
 #if defined(__LSBFIRST__)
 if (__isByteArray(__INST(digitByteArray))
 && __isLargeInteger(aLargeInteger)) {
-	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-	if (__isByteArray(_otherDigitByteArray)) {
+if (__isByteArray(_otherDigitByteArray)) {
-	    unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
+unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
-	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-	    INT _myLen = __byteArraySize(__INST(digitByteArray));
+INT _myLen = __byteArraySize(__INST(digitByteArray));
-	    if (_myLen == __POINTER_SIZE__) {
+if (_myLen == __POINTER_SIZE__) {
-		INT _otherLen = __byteArraySize(_otherDigitByteArray);
+INT _otherLen = __byteArraySize(_otherDigitByteArray);
-		if (_otherLen == __POINTER_SIZE__) {
+if (_otherLen == __POINTER_SIZE__) {
-		    unsigned INT _myVal = *((unsigned INT *)_myDigits);
+unsigned INT _myVal = *((unsigned INT *)_myDigits);
-		    unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
+unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
-		    RETURN( (_myVal <= _otherVal) ? true : false );
+RETURN( (_myVal <= _otherVal) ? true : false );
-		}
+}
-	    }
+}
 # if defined(UINT64) && (__POINTER_SIZE__ != 8)
-	    if (_myLen == __POINTER_SIZE__) {
+if (_myLen == __POINTER_SIZE__) {
-		INT _otherLen = __byteArraySize(_otherDigitByteArray);
+INT _otherLen = __byteArraySize(_otherDigitByteArray);
-		if (_otherLen <= 8) {
+if (_otherLen <= 8) {
-		    UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
+UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
-		    UINT64 _otherVal = *((UINT64 *)_otherDigits);
+UINT64 _otherVal = *((UINT64 *)_otherDigits);
-		    RETURN( (_myVal <= _otherVal) ? true : false );
+RETURN( (_myVal <= _otherVal) ? true : false );
-		}
+}
-	    } else {
+} else {
-		if (_myLen <= 8) {
+if (_myLen <= 8) {
-		    INT _otherLen = __byteArraySize(_otherDigitByteArray);
+INT _otherLen = __byteArraySize(_otherDigitByteArray);
-		    if (_otherLen <= 8) {
+if (_otherLen <= 8) {
-			UINT64 _myVal = (*((UINT64 *)_myDigits));
+UINT64 _myVal = (*((UINT64 *)_myDigits));
-			UINT64 _otherVal = *((UINT64 *)_otherDigits);
+UINT64 _otherVal = *((UINT64 *)_otherDigits);
-			RETURN( (_myVal <= _otherVal) ? true : false );
+RETURN( (_myVal <= _otherVal) ? true : false );
-		    }
+}
-		    if (_otherLen == __POINTER_SIZE__) {
+if (_otherLen == __POINTER_SIZE__) {
-			UINT64 _myVal = (*((UINT64 *)_myDigits));
+UINT64 _myVal = (*((UINT64 *)_myDigits));
-			UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
+UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
-			RETURN( (_myVal <= _otherVal) ? true : false );
+RETURN( (_myVal <= _otherVal) ? true : false );
-		    }
+}
-		}
+}
-	    }
+}
 # endif /* UINT64 */
-	}
+}
 }
 #endif /* LSBFIRST */
 %}.
 myLen := digitByteArray size.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [(digitByteArray basicAt:myLen) == 0] whileTrue:[
-	myLen := myLen - 1
+myLen := myLen - 1
 ].
 [(otherDigitByteArray basicAt:otherLen) == 0] whileTrue:[
-	otherLen := otherLen - 1
+otherLen := otherLen - 1
 ].
 (myLen < otherLen) ifTrue:[^ true].
 (myLen > otherLen) ifTrue:[^ false].
 [myLen > 0] whileTrue:[
-	d1 := digitByteArray basicAt:myLen.
+d1 := digitByteArray basicAt:myLen.
-	d2 := otherDigitByteArray basicAt:myLen.
+d2 := otherDigitByteArray basicAt:myLen.
-	d1 == d2 ifFalse:[
+d1 == d2 ifFalse:[
-	    (d1 < d2) ifTrue:[^ true].
+(d1 < d2) ifTrue:[^ true].
-	    ^ false.
+^ false.
-	].
+].
-	myLen := myLen - 1
+myLen := myLen - 1
 ].
 ^ true
 "Created: / 13.2.1998 / 12:19:45 / stefan"
 "Modified: / 30.4.1999 / 12:46:31 / stefan"
 %{
 OBJ _digitByteArray = __INST(digitByteArray);
 if (__isByteArray(_digitByteArray)
 && __isByteArray(otherDigitByteArray)) {
-	int _len1, _len2, _newLen;
+int _len1, _len2, _newLen;
-	unsigned char *_myDigits, *_otherDigits, *_newDigits;
+unsigned char *_myDigits, *_otherDigits, *_newDigits;
-	int _index, _carry;
+int _index, _carry;
-	int _comLen;
+int _comLen;
-	_len1 = __byteArraySize(_digitByteArray);
+_len1 = __byteArraySize(_digitByteArray);
-	_len2 = __byteArraySize(otherDigitByteArray);
+_len2 = __byteArraySize(otherDigitByteArray);
-	_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
+_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
-	_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-	if (_len1 < _len2) {
+if (_len1 < _len2) {
-	    _comLen = _len1;
+_comLen = _len1;
-	    _newLen = _len2;
+_newLen = _len2;
-	    if (_otherDigits[_len2 - 1] == 0xFF) _newLen++;
+if (_otherDigits[_len2 - 1] == 0xFF) _newLen++;
-	} else if (_len2 < _len1) {
+} else if (_len2 < _len1) {
-	    _comLen = _len2;
+_comLen = _len2;
-	    _newLen = _len1;
+_newLen = _len1;
-	    if (_myDigits[_len1 - 1] == 0xFF) _newLen++;
+if (_myDigits[_len1 - 1] == 0xFF) _newLen++;
-	} else {
+} else {
-	    /*
+/*
-	     * there can only be an overflow from the high bytes,
+* there can only be an overflow from the high bytes,
-	     * if their sum is >= 255
+* if their sum is >= 255
-	     * (with sum==255, a carry could still occur from the next lower bytes)
+* (with sum==255, a carry could still occur from the next lower bytes)
-	     */
+*/
-	    _newLen = _len1;
+_newLen = _len1;
-	    if ((_otherDigits[_len2 - 1] + _myDigits[_len1 - 1]) >= 0xFF) {
+if ((_otherDigits[_len2 - 1] + _myDigits[_len1 - 1]) >= 0xFF) {
-		_newLen++;
+_newLen++;
-	    } else {
+} else {
-		if (_newLen == sizeof(INT)) {
+if (_newLen == sizeof(INT)) {
-		    OBJ _uint;
+OBJ _uint;
-		    /*
+/*
-		     * two word-sized numbers, no carry - a very common case ...
+* two word-sized numbers, no carry - a very common case ...
-		     */
+*/
 #if defined(__LSB_FIRST__)
-		    unsigned INT _sum = *(unsigned INT *)_otherDigits + *(unsigned INT *)_myDigits;
+unsigned INT _sum = *(unsigned INT *)_otherDigits + *(unsigned INT *)_myDigits;
 #else
-		    unsigned INT _sum = __unsignedLongIntVal(self) + __unsignedLongIntVal(aLargeInteger);
+unsigned INT _sum = __unsignedLongIntVal(self) + __unsignedLongIntVal(aLargeInteger);
 #endif /* not LSB_FIRST */
-		    if (_sum <= _MAX_INT) {
+if (_sum <= _MAX_INT) {
-			_uint = __mkSmallInteger(_sum * __intVal(newSign));
+_uint = __mkSmallInteger(_sum * __intVal(newSign));
-		    } else {
+} else {
-			_uint = __MKULARGEINT(_sum);
+_uint = __MKULARGEINT(_sum);
-			__LargeIntegerInstPtr(_uint)->l_sign = newSign;
+__LargeIntegerInstPtr(_uint)->l_sign = newSign;
-		    }
+}
-		    RETURN (_uint);
+RETURN (_uint);
-		}
+}
-	    }
+}
-	    _comLen = _len1;
+_comLen = _len1;
-	}
+}
-	resultDigitByteArray = __BYTEARRAY_UNINITIALIZED_NEW_INT(_newLen);
+resultDigitByteArray = __BYTEARRAY_UNINITIALIZED_NEW_INT(_newLen);
-	/*
+/*
-	 * must refetch - GC could have been invoked
+* must refetch - GC could have been invoked
-	 */
+*/
-	_digitByteArray = __INST(digitByteArray);
+_digitByteArray = __INST(digitByteArray);
-	_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-	_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
+_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
-	_newDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
+_newDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
-	/*
+/*
-	 * add them ...
+* add them ...
-	 */
+*/
-	_index = 1;
+_index = 1;
-	_carry = 0;
+_carry = 0;
 #if defined(__LSBFIRST__)
 # if (__POINTER_SIZE__ == 8) && defined(__GNUC__)
 #  if 0  /* not faster (on alpha) */
-	{
+{
-	    int _comLen7;
+int _comLen7;
-	    /*
+/*
-	     * have a 64bit integers;
+* have a 64bit integers;
-	     * add quad-wise
+* add quad-wise
-	     * accessing bytes at: [index-1][index][index+1]..[index+6]
+* accessing bytes at: [index-1][index][index+1]..[index+6]
-	     */
+*/
-	    _comLen7 = _comLen - 3 - 4;
+_comLen7 = _comLen - 3 - 4;
-	    while (_index <= _comLen7) {
+while (_index <= _comLen7) {
-		UINT64 _sum, _t1, _t2;
+UINT64 _sum, _t1, _t2;
-		asm ("addq   %5,%6,%1         /* sum */                  \n\
+asm ("addq   %5,%6,%1         /* sum */                  \n\
-		      addq   %0,%1,%1         /* plus carryIn */         \n\
+addq   %0,%1,%1         /* plus carryIn */         \n\
-		      cmpult %1,%5,%2         /* was there a carry ? */  \n\
+cmpult %1,%5,%2         /* was there a carry ? */  \n\
-		      cmpult %1,%6,%3         /* was there a carry ? */  \n\
+cmpult %1,%6,%3         /* was there a carry ? */  \n\
-		      bis    %2,%3,%0         /* carryOut */             \n\
+bis    %2,%3,%0         /* carryOut */             \n\
-		     "
+"
-			: "=r"  (_carry),
+: "=r"  (_carry),
-			  "=r"  (_sum),
+"=r"  (_sum),
-			  "r"   (_t1),
+"r"   (_t1),
-			  "r"   (_t2)
+"r"   (_t2)
-			: "r"   (_carry),
+: "r"   (_carry),
-			  "r"   (((unsigned long *)(&(_myDigits[_index - 1])))[0]),
+"r"   (((unsigned long *)(&(_myDigits[_index - 1])))[0]),
-			  "r"   (((unsigned long *)(&(_otherDigits[_index - 1])))[0])
+"r"   (((unsigned long *)(&(_otherDigits[_index - 1])))[0])
-		    );
+);
-		/* _sum = _sum & 0xFFFFFFFF; */
+/* _sum = _sum & 0xFFFFFFFF; */
-		((unsigned long *)(&(_newDigits[_index - 1])))[0] = _sum;
+((unsigned long *)(&(_newDigits[_index - 1])))[0] = _sum;
-		_index += 8;
+_index += 8;
-	    }
+}
-	}
+}
 #  endif
 # endif /* 64bit */
 # if (__POINTER_SIZE__ == 8)
 # if 0  /* not faster (on alpha) */
-	{
+{
-	    int _comLen7;
+int _comLen7;
-	    /*
+/*
-	     * have a 64bit integers;
+* have a 64bit integers;
-	     * add quad-wise
+* add quad-wise
-	     * accessing bytes at: [index-1][index][index+1]..[index+6]
+* accessing bytes at: [index-1][index][index+1]..[index+6]
-	     */
+*/
-	    _comLen7 = _comLen - 3 - 4;
+_comLen7 = _comLen - 3 - 4;
-	    while (_index <= _comLen7) {
+while (_index <= _comLen7) {
-		UINT64 _sum, _t1, _t2;
+UINT64 _sum, _t1, _t2;
-		_t1 = ((UINT64 *)(&(_myDigits[_index - 1])))[0];
+_t1 = ((UINT64 *)(&(_myDigits[_index - 1])))[0];
-		_t2 = ((UINT64 *)(&(_otherDigits[_index - 1])))[0];
+_t2 = ((UINT64 *)(&(_otherDigits[_index - 1])))[0];
-		_sum = _t1 + _t2 + _carry;
+_sum = _t1 + _t2 + _carry;
-		((UINT64 *)(&(_newDigits[_index - 1])))[0] = _sum;
+((UINT64 *)(&(_newDigits[_index - 1])))[0] = _sum;
-		_carry = (_sum < _t1) | (_sum < _t2);
+_carry = (_sum < _t1) | (_sum < _t2);
-		_index += 8;
+_index += 8;
-	    }
+}
-	}
+}
 #  endif
 # endif /* 64bit */
 # ifdef UINT64
-	{
+{
-	    int _comLen3;
+int _comLen3;
-	    /*
+/*
-	     * have a 64bit integer type;
+* have a 64bit integer type;
-	     * add int-wise
+* add int-wise
-	     * accessing bytes at: [index-1][index][index+1][index+2]
+* accessing bytes at: [index-1][index][index+1][index+2]
-	     */
+*/
-	    _comLen3 = _comLen - 3;
+_comLen3 = _comLen - 3;
-	    while (_index <= _comLen3) {
+while (_index <= _comLen3) {
-		UINT64 _sum;
+UINT64 _sum;
-		/* do not merge the 3 lines below into one -
+/* do not merge the 3 lines below into one -
-		 * (will do sign extension then, which is wrong here)
+* (will do sign extension then, which is wrong here)
-		 */
+*/
-		_sum = (unsigned)_carry;
+_sum = (unsigned)_carry;
-		_sum += ((unsigned int *)(&(_myDigits[_index - 1])))[0];
+_sum += ((unsigned int *)(&(_myDigits[_index - 1])))[0];
-		_sum += ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
+_sum += ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
-		_carry = _sum >> 32;
+_carry = _sum >> 32;
-		/* _sum = _sum & 0xFFFFFFFF; */
+/* _sum = _sum & 0xFFFFFFFF; */
-		((unsigned int *)(&(_newDigits[_index - 1])))[0] = _sum;
+((unsigned int *)(&(_newDigits[_index - 1])))[0] = _sum;
-		_index += 4;
+_index += 4;
-	    }
+}
-	}
+}
 # else
 #  if defined(__i386__) && defined(__GNUC__) && (__POINTER_SIZE__ == 4)
-	{
+{
-	    int _comLen3;
+int _comLen3;
-	    _comLen3 = _comLen - 3 - 4;
+_comLen3 = _comLen - 3 - 4;
-	    while (_index <= _comLen3) {
+while (_index <= _comLen3) {
-		unsigned int _sum, _sum2;
+unsigned int _sum, _sum2;
-		unsigned int __in1A, __in1B, __in2A, __in2B;
+unsigned int __in1A, __in1B, __in2A, __in2B;
-		__in1A = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
+__in1A = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
-		__in2A = ((unsigned int *)(&(_myDigits[_index - 1])))[1];
+__in2A = ((unsigned int *)(&(_myDigits[_index - 1])))[1];
-		__in1B = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
+__in1B = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
-		__in2B = ((unsigned int *)(&(_otherDigits[_index - 1])))[1];
+__in2B = ((unsigned int *)(&(_otherDigits[_index - 1])))[1];
-		asm ("addl %%edx,%%eax  \n\
+asm ("addl %%edx,%%eax  \n\
-		      movl $0,%%edx     \n\
+movl $0,%%edx     \n\
-		      adcl $0,%%edx     \n\
+adcl $0,%%edx     \n\
-		      addl %5,%%eax     \n\
+addl %5,%%eax     \n\
-		      adcl $0,%%edx     \n\
+adcl $0,%%edx     \n\
-					\n\
+\n\
-		      addl %%edx,%%ecx  \n\
+addl %%edx,%%ecx  \n\
-		      movl $0,%%edx     \n\
+movl $0,%%edx     \n\
-		      adcl $0,%%edx     \n\
+adcl $0,%%edx     \n\
-		      addl %7,%%ecx     \n\
+addl %7,%%ecx     \n\
-		      adcl $0,%%edx     \n\
+adcl $0,%%edx     \n\
-		     "
+"
-			: "=d"  (_carry),
+: "=d"  (_carry),
-			  "=a"  (_sum),
+"=a"  (_sum),
-			  "=c"  (_sum2)
+"=c"  (_sum2)
-			: "0"   (_carry),
+: "0"   (_carry),
-			  "1"   (__in1A),
+"1"   (__in1A),
-			  "rm"  (__in1B),
+"rm"  (__in1B),
-			  "2"   (__in2A),
+"2"   (__in2A),
-			  "rm"  (__in2B)
+"rm"  (__in2B)
-		    );
+);
-		((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
+((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
-		((unsigned *)(&(_newDigits[_index - 1])))[1] = _sum2;
+((unsigned *)(&(_newDigits[_index - 1])))[1] = _sum2;
-		_index += 8;
+_index += 8;
-	    }
+}
-	    /*
+/*
-	     * add int-wise
+* add int-wise
-	     * accessing bytes at: [index-1][index][index+1][index+2]
+* accessing bytes at: [index-1][index][index+1][index+2]
-	     */
+*/
-	    _comLen3 = _comLen3 + 4;
+_comLen3 = _comLen3 + 4;
-	    if (_index <= _comLen3) {
+if (_index <= _comLen3) {
-		unsigned int _sum;
+unsigned int _sum;
-		unsigned int __inA, __inB;
+unsigned int __inA, __inB;
-		__inA = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
+__inA = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
-		__inB = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
+__inB = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
-		asm ("addl %%edx,%%eax      \n\
+asm ("addl %%edx,%%eax      \n\
-		      movl $0,%%edx         \n\
+movl $0,%%edx         \n\
-		      adcl $0,%%edx         \n\
+adcl $0,%%edx         \n\
-		      addl %4,%%eax         \n\
+addl %4,%%eax         \n\
-		      adcl $0,%%edx"
+adcl $0,%%edx"
-			: "=d"  (_carry),
+: "=d"  (_carry),
-			  "=a"  (_sum)
+"=a"  (_sum)
-			: "0"   (_carry),
+: "0"   (_carry),
-			  "1"   (__inA),
+"1"   (__inA),
-			  "rm"  (__inB)
+"rm"  (__inB)
-		    );
+);
-		((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
+((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
-		_index += 4;
+_index += 4;
-	    }
+}
-	}
+}
 #  endif /* __i386__ && GNUC */
 #  if defined(WIN32) && defined(__BORLANDC__) && defined(__i386__) && (__POINTER_SIZE__ == 4)
-	{
+{
-	    int _comLen3;
+int _comLen3;
-	    /*
+/*
-	     * add long-wise
+* add long-wise
-	     * accessing bytes at: [index-1][index][index+1][index+2]
+* accessing bytes at: [index-1][index][index+1][index+2]
-	     */
+*/
-	    _comLen3 = _comLen - 3;
+_comLen3 = _comLen - 3;
-	    while (_index <= _comLen3) {
+while (_index <= _comLen3) {
-		unsigned int _sum, _v1, _v2;
+unsigned int _sum, _v1, _v2;
-		_v1 = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
+_v1 = ((unsigned int *)(&(_myDigits[_index - 1])))[0];
-		_v2 = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
+_v2 = ((unsigned int *)(&(_otherDigits[_index - 1])))[0];
-		asm {
+asm {
-		      mov eax, _v1
+mov eax, _v1
-		      add eax, _v2
+add eax, _v2
-		      mov edx, 0
+mov edx, 0
-		      adc edx, 0
+adc edx, 0
-		      add eax, _carry
+add eax, _carry
-		      adc edx, 0
+adc edx, 0
-		      mov _carry, edx
+mov _carry, edx
-		      mov _sum, eax
+mov _sum, eax
-		    }
+}
-		((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
+((unsigned *)(&(_newDigits[_index - 1])))[0] = _sum;
-		_index += 4;
+_index += 4;
-	    }
+}
-	}
+}
 #  endif /* __i386__ && WIN32 */
 # endif /* INT64 */
-	/*
+/*
-	 * add short-wise
+* add short-wise
-	 * accessing bytes at: [index-1][index]
+* accessing bytes at: [index-1][index]
-	 */
+*/
-	while (_index < _comLen) {
+while (_index < _comLen) {
-	    unsigned int _sum;
+unsigned int _sum;
-	    _sum = _carry
+_sum = _carry
-		   + ((unsigned short *)(&(_myDigits[_index - 1])))[0]
++ ((unsigned short *)(&(_myDigits[_index - 1])))[0]
-		   + ((unsigned short *)(&(_otherDigits[_index - 1])))[0];
++ ((unsigned short *)(&(_otherDigits[_index - 1])))[0];
-	    _carry = _sum >> 16;
+_carry = _sum >> 16;
-	    /* _sum = _sum & 0xFFFF; */
+/* _sum = _sum & 0xFFFF; */
-	    *(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
+*(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
-	    _index += 2;
+_index += 2;
-	}
+}
 #else
 # ifdef __sparc__
-	/*
+/*
-	 * add short-wise
+* add short-wise
-	 * accessing bytes at: [index-1][index]
+* accessing bytes at: [index-1][index]
-	 */
+*/
-	while (_index < _comLen) {
+while (_index < _comLen) {
-	    unsigned int _sum;
+unsigned int _sum;
-	    unsigned short _v1, _v2;
+unsigned short _v1, _v2;
-	    _v1 = ((unsigned short *)(&(_myDigits[_index - 1])))[0];
+_v1 = ((unsigned short *)(&(_myDigits[_index - 1])))[0];
-	    _v2 = ((unsigned short *)(&(_otherDigits[_index - 1])))[0];
+_v2 = ((unsigned short *)(&(_otherDigits[_index - 1])))[0];
-	    _sum = _carry + (_v1>>8) + (_v2>>8);
+_sum = _carry + (_v1>>8) + (_v2>>8);
-	    _carry = _sum >> 8;
+_carry = _sum >> 8;
-	    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-	    _sum = _carry + (_v1 & 0xFF) + (_v2 & 0xFF);
+_sum = _carry + (_v1 & 0xFF) + (_v2 & 0xFF);
-	    _carry = _sum >> 8;
+_carry = _sum >> 8;
-	    _newDigits[_index] = _sum;
+_newDigits[_index] = _sum;
-	    _index += 2;
+_index += 2;
-	}
+}
 # endif
 #endif /* __LSBFIRST__ */
-	/*
+/*
-	 * add byte-wise
+* add byte-wise
-	 */
+*/
-	while (_index <= _comLen) {
+while (_index <= _comLen) {
-	    unsigned int _sum;
+unsigned int _sum;
-	    _sum = _carry
+_sum = _carry
-		   + _myDigits[_index - 1]
++ _myDigits[_index - 1]
-		   + _otherDigits[_index - 1];
++ _otherDigits[_index - 1];
-	    _carry = _sum >> 8;
+_carry = _sum >> 8;
-	    /* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-	    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-	    _index++;
+_index++;
-	}
+}
-	/*
+/*
-	 * rest
+* rest
-	 */
+*/
-	if (_len1 > _len2) {
+if (_len1 > _len2) {
 #if defined(__LSBFIRST__)
-	    if (_index <= _len1) {
+if (_index <= _len1) {
-		if ((_index - 1) & 1) {
+if ((_index - 1) & 1) {
-		    /* odd byte */
+/* odd byte */
-		    unsigned int _sum;
+unsigned int _sum;
-		    _sum = _carry + _myDigits[_index - 1];
+_sum = _carry + _myDigits[_index - 1];
-		    _carry = _sum >> 8;
+_carry = _sum >> 8;
-		    /* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-		    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-		    _index++;
+_index++;
-		}
+}
-		while (_index < _len1) {
+while (_index < _len1) {
-		    /* shorts */
+/* shorts */
-		    unsigned int _sum;
+unsigned int _sum;
-		    _sum = _carry + *(unsigned short *)(&(_myDigits[_index - 1]));
+_sum = _carry + *(unsigned short *)(&(_myDigits[_index - 1]));
-		    _carry = _sum >> 16;
+_carry = _sum >> 16;
-		    /* _sum = _sum & 0xFFFF; */
+/* _sum = _sum & 0xFFFF; */
-		    *(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
+*(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
-		    _index += 2;
+_index += 2;
-		}
+}
-		if (_index <= _len1) {
+if (_index <= _len1) {
-		    /* last byte */
+/* last byte */
-		    unsigned int _sum;
+unsigned int _sum;
-		    _sum = _carry + _myDigits[_index - 1];
+_sum = _carry + _myDigits[_index - 1];
-		    _carry = _sum >> 8;
+_carry = _sum >> 8;
-		    /* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-		    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-		    _index++;
+_index++;
-		}
+}
-	    }
+}
 #else
-	    while (_index <= _len1) {
+while (_index <= _len1) {
-		unsigned int _sum;
+unsigned int _sum;
-		_sum = _carry + _myDigits[_index - 1];
+_sum = _carry + _myDigits[_index - 1];
-		_carry = _sum >> 8;
+_carry = _sum >> 8;
-		/* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-		_newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-		_index++;
+_index++;
-	    }
+}
 #endif /* not LSB */
-	} else {
+} else {
-	    if (_len2 > _len1) {
+if (_len2 > _len1) {
 #if defined(__LSBFIRST__)
-		if (_index <= _len2) {
+if (_index <= _len2) {
-		    if ((_index - 1) & 1) {
+if ((_index - 1) & 1) {
-			/* odd byte */
+/* odd byte */
-			unsigned int _sum;
+unsigned int _sum;
-			_sum = _carry + _otherDigits[_index - 1];
+_sum = _carry + _otherDigits[_index - 1];
-			_carry = _sum >> 8;
+_carry = _sum >> 8;
-			/* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-			_newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-			_index++;
+_index++;
-		    }
+}
-		    while (_index < _len2) {
+while (_index < _len2) {
-			/* shorts */
+/* shorts */
-			unsigned int _sum;
+unsigned int _sum;
-			_sum = _carry + *(unsigned short *)(&(_otherDigits[_index - 1]));
+_sum = _carry + *(unsigned short *)(&(_otherDigits[_index - 1]));
-			_carry = _sum >> 16;
+_carry = _sum >> 16;
-			/* _sum = _sum & 0xFFFF; */
+/* _sum = _sum & 0xFFFF; */
-			*(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
+*(unsigned short *)(&(_newDigits[_index - 1])) = _sum;
-			_index += 2;
+_index += 2;
-		    }
+}
-		    if (_index <= _len2) {
+if (_index <= _len2) {
-			/* last byte */
+/* last byte */
-			unsigned int _sum;
+unsigned int _sum;
-			_sum = _carry + _otherDigits[_index - 1];
+_sum = _carry + _otherDigits[_index - 1];
-			_carry = _sum >> 8;
+_carry = _sum >> 8;
-			/* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-			_newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-			_index++;
+_index++;
-		    }
+}
-		}
+}
 #else
-		while (_index <= _len2) {
+while (_index <= _len2) {
-		    unsigned int _sum;
+unsigned int _sum;
-		    _sum = _carry + _otherDigits[_index - 1];
+_sum = _carry + _otherDigits[_index - 1];
-		    _carry = _sum >> 8;
+_carry = _sum >> 8;
-		    /* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-		    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-		    _index++;
+_index++;
-		}
+}
 #endif /* not LSB */
-	    }
+}
-	}
+}
-	while (_index <= _newLen) {
+while (_index <= _newLen) {
-	    unsigned int _sum;
+unsigned int _sum;
-	    _sum = _carry;
+_sum = _carry;
-	    _carry = _sum >> 8;
+_carry = _sum >> 8;
-	    /* _sum = _sum & 0xFF; */
+/* _sum = _sum & 0xFF; */
-	    _newDigits[_index - 1] = _sum;
+_newDigits[_index - 1] = _sum;
-	    _index++;
+_index++;
-	}
+}
 }
 %}.
 resultDigitByteArray notNil ifTrue:[
-	result := self class basicNew.
+result := self class basicNew.
-	result setDigits:resultDigitByteArray.
+result setDigits:resultDigitByteArray.
-	result setSign:newSign.
+result setSign:newSign.
 ] ifFalse:[
-	len1 := digitByteArray size.
+len1 := digitByteArray size.
-	len2 := otherDigitByteArray size.
+len2 := otherDigitByteArray size.
-	"/ earlier versions estimated the newLength as:
+"/ earlier versions estimated the newLength as:
-	"/ (len1 max:len2) + 1
+"/ (len1 max:len2) + 1
-	"/ and reduced the result.
+"/ and reduced the result.
-	"/ however, if one of the addends is smaller,
+"/ however, if one of the addends is smaller,
-	"/ the result will never require another digit,
+"/ the result will never require another digit,
-	"/ if the highest digit of the larger addent is
+"/ if the highest digit of the larger addent is
-	"/ not equal to 255. Therefore, in most cases,
+"/ not equal to 255. Therefore, in most cases,
-	"/ we can avoid the computation and resizing
+"/ we can avoid the computation and resizing
-	"/ in #reduced.
+"/ in #reduced.
-	len1 < len2 ifTrue:[
+len1 < len2 ifTrue:[
-	    newLen := len2.
+newLen := len2.
-	    (otherDigitByteArray at:len2) == 16rFF ifTrue:[
+(otherDigitByteArray at:len2) == 16rFF ifTrue:[
-		newLen := newLen + 1
+newLen := newLen + 1
-	    ]
+]
-	] ifFalse:[
+] ifFalse:[
-	    len2 < len1 ifTrue:[
+len2 < len1 ifTrue:[
-		newLen := len1.
+newLen := len1.
-		(digitByteArray at:len1) == 16rFF ifTrue:[
+(digitByteArray at:len1) == 16rFF ifTrue:[
-		    newLen := newLen + 1
+newLen := newLen + 1
-		]
+]
-	    ] ifFalse:[
+] ifFalse:[
-		newLen := len1 + 1.
+newLen := len1 + 1.
-	    ]
+]
-	].
+].
-	result := self class basicNew numberOfDigits:newLen.
+result := self class basicNew numberOfDigits:newLen.
-	result sign:newSign.
+result sign:newSign.
-	resultDigitByteArray := result digitBytes.
+resultDigitByteArray := result digitBytes.
-	index := 1.
+index := 1.
-	carry := 0.
+carry := 0.
-	done := false.
+done := false.
-	[done] whileFalse:[
+[done] whileFalse:[
-	    sum := carry.
+sum := carry.
-	    (index <= len1) ifTrue:[
+(index <= len1) ifTrue:[
-		sum := sum + (digitByteArray basicAt:index).
+sum := sum + (digitByteArray basicAt:index).
-		(index <= len2) ifTrue:[
+(index <= len2) ifTrue:[
-		    sum := sum + (otherDigitByteArray basicAt:index)
+sum := sum + (otherDigitByteArray basicAt:index)
-		]
+]
-	    ] ifFalse:[
+] ifFalse:[
-		(index <= len2) ifTrue:[
+(index <= len2) ifTrue:[
-		    sum := sum + (otherDigitByteArray basicAt:index)
+sum := sum + (otherDigitByteArray basicAt:index)
-		] ifFalse:[
+] ifFalse:[
-		    "end reached"
+"end reached"
-		    done := true
+done := true
-		]
+]
-	    ].
+].
-	    (sum >= 16r100) ifTrue:[
+(sum >= 16r100) ifTrue:[
-		carry := 1.
+carry := 1.
-		sum := sum - 16r100
+sum := sum - 16r100
-	    ] ifFalse:[
+] ifFalse:[
-		carry := 0
+carry := 0
-	    ].
+].
-	    resultDigitByteArray basicAt:index put:sum.
+resultDigitByteArray basicAt:index put:sum.
-	    index := index + 1
+index := index + 1
-	].
+].
 ].
 ^ result compressed
 "Modified: 11.8.1997 / 03:23:37 / cg"
 !
 absSubtract:aLargeInteger
 "private helper for division:
-	destructively subtract aLargeInteger from myself
+destructively subtract aLargeInteger from myself
-	AND return true, if the result is non-zero, false otherwise.
+AND return true, if the result is non-zero, false otherwise.
-	(i.e. this method has both a return value and a side-effect
+(i.e. this method has both a return value and a side-effect
-	 on the receiver)
+on the receiver)
-	Only allowed for positive receiver and argument
+Only allowed for positive receiver and argument
-	The receiver must be >= the argument.
+The receiver must be >= the argument.
-	The receiver must be a temporary scratch-number"
+The receiver must be a temporary scratch-number"
 |otherDigitByteArray
 len1   "{ Class: SmallInteger }"
 len2   "{ Class: SmallInteger }"
 index  "{ Class: SmallInteger }"
 notZero := false.
 len1 := digitByteArray size.
 otherDigitByteArray := aLargeInteger digitBytes.
 len2 := otherDigitByteArray size.
 len2 > len1 ifTrue:[
-	[(otherDigitByteArray at:len2) == 0] whileTrue:[
+[(otherDigitByteArray at:len2) == 0] whileTrue:[
-	    len2 := len2 - 1
+len2 := len2 - 1
-	].
+].
-	len2 > len1 ifTrue:[
+len2 > len1 ifTrue:[
-	    self error:'operation failed' "/ may not be called that way
+self error:'operation failed' "/ may not be called that way
-	].
+].
 ].
 "/ knowing that len2 is <= len1
 %{
 OBJ _digitByteArray = __INST(digitByteArray);
 if (__isByteArray(_digitByteArray)
 && __isByteArray(otherDigitByteArray)) {
-	int _len1 = __intVal(len1),
+int _len1 = __intVal(len1),
-	    _len2 = __intVal(len2);
+_len2 = __intVal(len2);
-	unsigned char *_myDigits, *_otherDigits;
+unsigned char *_myDigits, *_otherDigits;
-	int _index = 1, _borrow = 0;
+int _index = 1, _borrow = 0;
-	INT _diff;
+INT _diff;
-	int anyBitNonZero = 0;
+int anyBitNonZero = 0;
-	_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
+_otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
-	_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
 #if defined(__LSBFIRST__)
 # if __POINTER_SIZE__ == 8
-	{
+{
-	    int _len2Q;
+int _len2Q;
-	    /*
+/*
-	     * subtract int-wise
+* subtract int-wise
-	     */
+*/
-	    _len2Q = _len2-2;
+_len2Q = _len2-2;
-	    while (_index < _len2Q) {
+while (_index < _len2Q) {
-		/* do not combine the expression below (may lead to unsigned result on some machines */
+/* do not combine the expression below (may lead to unsigned result on some machines */
-		_diff = ((unsigned int *)(_myDigits+_index-1))[0];
+_diff = ((unsigned int *)(_myDigits+_index-1))[0];
-		_diff -= ((unsigned int *)(_otherDigits+_index-1))[0];
+_diff -= ((unsigned int *)(_otherDigits+_index-1))[0];
-		_diff -= _borrow;
+_diff -= _borrow;
-		if (_diff >= 0) {
+if (_diff >= 0) {
-		    _borrow = 0;
+_borrow = 0;
-		} else {
+} else {
-		    _borrow = 1;
+_borrow = 1;
-		    /* _diff += 0x10000; */
+/* _diff += 0x10000; */
-		}
+}
-		((unsigned int *)(_myDigits+_index-1))[0] = _diff;
+((unsigned int *)(_myDigits+_index-1))[0] = _diff;
-		anyBitNonZero |= (_diff & 0xFFFFFFFFL);
+anyBitNonZero |= (_diff & 0xFFFFFFFFL);
-		_index += 4;
+_index += 4;
-	    }
+}
-	}
+}
 # endif
-	/*
+/*
-	 * subtract short-wise
+* subtract short-wise
-	 */
+*/
-	while (_index < _len2) {
+while (_index < _len2) {
-	    /* do not combine the expression below (may lead to unsigned result on some machines */
+/* do not combine the expression below (may lead to unsigned result on some machines */
-	    _diff = ((unsigned short *)(_myDigits+_index-1))[0];
+_diff = ((unsigned short *)(_myDigits+_index-1))[0];
-	    _diff -= ((unsigned short *)(_otherDigits+_index-1))[0];
+_diff -= ((unsigned short *)(_otherDigits+_index-1))[0];
-	    _diff -= _borrow;
+_diff -= _borrow;
-	    if (_diff >= 0) {
+if (_diff >= 0) {
-		_borrow = 0;
+_borrow = 0;
-	    } else {
+} else {
-		_borrow = 1;
+_borrow = 1;
-		/* _diff += 0x10000; */
+/* _diff += 0x10000; */
-	    }
+}
-	    ((unsigned short *)(_myDigits+_index-1))[0] = _diff;
+((unsigned short *)(_myDigits+_index-1))[0] = _diff;
-	    anyBitNonZero |= (_diff & 0xFFFF);
+anyBitNonZero |= (_diff & 0xFFFF);
-	    _index += 2;
+_index += 2;
-	}
+}
-	if (_index <= _len2) {
+if (_index <= _len2) {
-	    /*
+/*
-	     * cannot continue with shorts - there is an odd number of
+* cannot continue with shorts - there is an odd number of
-	     * bytes in the minuent
+* bytes in the minuent
-	     */
+*/
-	} else {
+} else {
-	    while (_index < _len1) {
+while (_index < _len1) {
-		/* do not combine the expression below (may lead to unsigned result on some machines */
+/* do not combine the expression below (may lead to unsigned result on some machines */
-		_diff = ((unsigned short *)(_myDigits+_index-1))[0];
+_diff = ((unsigned short *)(_myDigits+_index-1))[0];
-		_diff -= _borrow;
+_diff -= _borrow;
-		if (_diff >= 0) {
+if (_diff >= 0) {
-		    /* _borrow = 0; */
+/* _borrow = 0; */
-		    ((unsigned short *)(_myDigits+_index-1))[0] = _diff;
+((unsigned short *)(_myDigits+_index-1))[0] = _diff;
-		    anyBitNonZero |= (_diff & 0xFFFF);
+anyBitNonZero |= (_diff & 0xFFFF);
-		    _index += 2;
+_index += 2;
-		    while (_index < _len1) {
+while (_index < _len1) {
-			anyBitNonZero |= ((unsigned short *)(_myDigits+_index-1))[0];
+anyBitNonZero |= ((unsigned short *)(_myDigits+_index-1))[0];
-			if (anyBitNonZero) {
+if (anyBitNonZero) {
-			    RETURN (true);
+RETURN (true);
-			}
+}
-			_index += 2;
+_index += 2;
-		    }
+}
-		    /* last odd index */
+/* last odd index */
-		    if (_index <= _len1) {
+if (_index <= _len1) {
-			anyBitNonZero |= _myDigits[_index - 1];;
+anyBitNonZero |= _myDigits[_index - 1];;
-			if (anyBitNonZero) {
+if (anyBitNonZero) {
-			    RETURN (true);
+RETURN (true);
-			}
+}
-			_index++;
+_index++;
-		    }
+}
-		    RETURN (anyBitNonZero ? true : false);
+RETURN (anyBitNonZero ? true : false);
-		}
+}
-		_borrow = 1;
+_borrow = 1;
-		/* _diff += 0x10000; */
+/* _diff += 0x10000; */
-		((unsigned short *)(_myDigits+_index-1))[0] = _diff;
+((unsigned short *)(_myDigits+_index-1))[0] = _diff;
-		anyBitNonZero |= (_diff & 0xFFFF);
+anyBitNonZero |= (_diff & 0xFFFF);
-		_index += 2;
+_index += 2;
-	    }
+}
-	}
+}
 #endif
-	/*
+/*
-	 * subtract byte-wise
+* subtract byte-wise
-	 */
+*/
-	while (_index <= _len2) {
+while (_index <= _len2) {
-	    /* do not combine the expression below (may lead to unsigned result on some machines */
+/* do not combine the expression below (may lead to unsigned result on some machines */
-	    _diff = _myDigits[_index - 1];
+_diff = _myDigits[_index - 1];
-	    _diff -= _otherDigits[_index - 1];
+_diff -= _otherDigits[_index - 1];
-	    _diff -= _borrow;
+_diff -= _borrow;
-	    if (_diff >= 0) {
+if (_diff >= 0) {
-		_borrow = 0;
+_borrow = 0;
-	    } else {
+} else {
-		_borrow = 1;
+_borrow = 1;
-		/* _diff += 0x100; */
+/* _diff += 0x100; */
-	    }
+}
-	    _myDigits[_index - 1] = _diff;
+_myDigits[_index - 1] = _diff;
-	    anyBitNonZero |= (_diff & 0xFF);
+anyBitNonZero |= (_diff & 0xFF);
-	    _index++;
+_index++;
-	}
+}
-	while (_index <= _len1) {
+while (_index <= _len1) {
-	    /* do not combine the expression below (may lead to unsigned result on some machines */
+/* do not combine the expression below (may lead to unsigned result on some machines */
-	    _diff = _myDigits[_index - 1];
+_diff = _myDigits[_index - 1];
-	    _diff -= _borrow;
+_diff -= _borrow;
-	    if (_diff >= 0) {
+if (_diff >= 0) {
-		/* _borrow = 0; */
+/* _borrow = 0; */
-		_myDigits[_index - 1] = _diff;
+_myDigits[_index - 1] = _diff;
-		anyBitNonZero |= (_diff & 0xFF);
+anyBitNonZero |= (_diff & 0xFF);
-		_index++;
+_index++;
-		while (_index <= _len1) {
+while (_index <= _len1) {
-		    anyBitNonZero |= _myDigits[_index - 1];
+anyBitNonZero |= _myDigits[_index - 1];
-		    if (anyBitNonZero) {
+if (anyBitNonZero) {
-			RETURN (true);
+RETURN (true);
-		    }
+}
-		    _index++;
+_index++;
-		}
+}
-		break;
+break;
-	    }
+}
-	    _borrow = 1;
+_borrow = 1;
-	    /* _diff += 0x100; */
+/* _diff += 0x100; */
-	    _myDigits[_index - 1] = _diff;
+_myDigits[_index - 1] = _diff;
-	    anyBitNonZero |= (_diff & 0xFF);
+anyBitNonZero |= (_diff & 0xFF);
-	    _index++;
+_index++;
-	}
+}
-	RETURN (anyBitNonZero ? true : false);
+RETURN (anyBitNonZero ? true : false);
 }
 %}.
 index := 1.
 borrow := 0.
 [index <= len1] whileTrue:[
-	diff := borrow.
+diff := borrow.
-	diff := diff + (digitByteArray basicAt:index).
+diff := diff + (digitByteArray basicAt:index).
-	index <= len2 ifTrue:[
+index <= len2 ifTrue:[
-	    diff := diff - (otherDigitByteArray basicAt:index).
+diff := diff - (otherDigitByteArray basicAt:index).
-	].
+].
-	"/ workaround for
+"/ workaround for
-	"/ gcc code generator bug
+"/ gcc code generator bug
-	(diff >= 0) ifTrue:[
+(diff >= 0) ifTrue:[
-	    borrow := 0
+borrow := 0
-	] ifFalse:[
+] ifFalse:[
-	    borrow := -1.
+borrow := -1.
-	    diff := diff + 16r100
+diff := diff + 16r100
-	].
+].
-	diff ~~ 0 ifTrue:[
+diff ~~ 0 ifTrue:[
-	    notZero := true
+notZero := true
-	].
+].
-	digitByteArray basicAt:index put:diff.
+digitByteArray basicAt:index put:diff.
-	index := index + 1
+index := index + 1
 ].
 ^ notZero
 "Created: / 5.11.1996 / 16:23:47 / cg"
 %{  /* NOCONTEXT */
 OBJ __digits = __INST(digitByteArray);
 if (__isByteArray(__digits)) {
-	int __nBytes = __byteArraySize(__digits);
+int __nBytes = __byteArraySize(__digits);
-	unsigned char *__bp = __ByteArrayInstPtr(__digits)->ba_element;
+unsigned char *__bp = __ByteArrayInstPtr(__digits)->ba_element;
-	unsigned INT __this, __next;
+unsigned INT __this, __next;
-	int __idx;
+int __idx;
-	if (__nBytes == 1) {
+if (__nBytes == 1) {
-	    __bp[0] >>= 1;
+__bp[0] >>= 1;
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	__idx = 1;
+__idx = 1;
 #if defined(__LSBFIRST__)
 # if (__POINTER_SIZE__ == 8)
-	if (sizeof(unsigned INT) == 8) {
+if (sizeof(unsigned INT) == 8) {
-	    int __endIndex = __nBytes - 8;
+int __endIndex = __nBytes - 8;
-	    if (__idx < __endIndex) {
+if (__idx < __endIndex) {
-		__this = ((unsigned INT *)__bp)[0];
+__this = ((unsigned INT *)__bp)[0];
-		while (__idx < __endIndex) {
+while (__idx < __endIndex) {
-		    __next = ((unsigned INT *)__bp)[1];
+__next = ((unsigned INT *)__bp)[1];
-		    __this = (__this >> 1) /* & 0x7FFFFFFFFFFFFFF */;
+__this = (__this >> 1) /* & 0x7FFFFFFFFFFFFFF */;
-		    __this |= __next << 63;
+__this |= __next << 63;
-		    ((unsigned INT *)__bp)[0] = __this;
+((unsigned INT *)__bp)[0] = __this;
-		    __this = __next;
+__this = __next;
-		    __bp += 8;
+__bp += 8;
-		    __idx += 8;
+__idx += 8;
-		}
+}
-	    }
+}
-	    if (__idx < (__nBytes - 4)) {
+if (__idx < (__nBytes - 4)) {
-		__this = ((unsigned int *)__bp)[0];
+__this = ((unsigned int *)__bp)[0];
-		__next = ((unsigned int *)__bp)[1];
+__next = ((unsigned int *)__bp)[1];
-		__this = (__this >> 1) /* & 0x7FFFFFF */;
+__this = (__this >> 1) /* & 0x7FFFFFF */;
-		__this |= __next << 31;
+__this |= __next << 31;
-		((unsigned int *)__bp)[0] = __this;
+((unsigned int *)__bp)[0] = __this;
-		__this = __next;
+__this = __next;
-		__bp += 4;
+__bp += 4;
-		__idx += 4;
+__idx += 4;
-	    }
+}
-	    if (__idx < (__nBytes - 2)) {
+if (__idx < (__nBytes - 2)) {
-		__this = ((unsigned short *)__bp)[0];
+__this = ((unsigned short *)__bp)[0];
-		__next = ((unsigned short *)__bp)[1];
+__next = ((unsigned short *)__bp)[1];
-		__this = (__this >> 1) /* & 0x7FFFFFF */;
+__this = (__this >> 1) /* & 0x7FFFFFF */;
-		__this |= __next << 15;
+__this |= __next << 15;
-		((unsigned short *)__bp)[0] = __this;
+((unsigned short *)__bp)[0] = __this;
-		__this = __next;
+__this = __next;
-		__bp += 2;
+__bp += 2;
-		__idx += 2;
+__idx += 2;
-	    }
+}
-	}
+}
 # else
-	if (sizeof(unsigned int) == 4) {
+if (sizeof(unsigned int) == 4) {
-	    int __endIndex = __nBytes - 4;
+int __endIndex = __nBytes - 4;
-	    if (__idx < __endIndex) {
+if (__idx < __endIndex) {
-		__this = ((unsigned int *)__bp)[0];
+__this = ((unsigned int *)__bp)[0];
-		while (__idx < __endIndex) {
+while (__idx < __endIndex) {
-		    __next = ((unsigned int *)__bp)[1];
+__next = ((unsigned int *)__bp)[1];
-		    __this = (__this >> 1) /* & 0x7FFFFFF */;
+__this = (__this >> 1) /* & 0x7FFFFFF */;
-		    __this |= __next << 31;
+__this |= __next << 31;
-		    ((unsigned int *)__bp)[0] = __this;
+((unsigned int *)__bp)[0] = __this;
-		    __this = __next;
+__this = __next;
-		    __bp += 4;
+__bp += 4;
-		    __idx += 4;
+__idx += 4;
-		}
+}
-	    }
+}
-	}
+}
 # endif
 #endif
-	__this = __bp[0];
+__this = __bp[0];
-	while (__idx < __nBytes) {
+while (__idx < __nBytes) {
-	    __next = __bp[1];
+__next = __bp[1];
-	    __this >>= 1;
+__this >>= 1;
-	    __this |= __next << 7;
+__this |= __next << 7;
-	    __bp[0] = __this;
+__bp[0] = __this;
-	    __this = __next;
+__this = __next;
-	    __bp++;
+__bp++;
-	    __idx++;
+__idx++;
-	}
+}
-	__bp[0] = __this >> 1;
+__bp[0] = __this >> 1;
-	RETURN (self);
+RETURN (self);
 }
 %}.
 prevBit := 0.
 digitByteArray size to:1 by:-1 do:[:idx |
-	|thisByte|
+|thisByte|
-	thisByte := digitByteArray at:idx.
+thisByte := digitByteArray at:idx.
-	digitByteArray at:idx put:((thisByte bitShift:-1) bitOr:prevBit).
+digitByteArray at:idx put:((thisByte bitShift:-1) bitOr:prevBit).
-	prevBit := (thisByte bitAnd:1) bitShift:7.
+prevBit := (thisByte bitAnd:1) bitShift:7.
 ].
 "
 100000 asLargeInteger div2
 1000000000000000000000000000 div2
 nBytes := digitByteArray size.
 b := digitByteArray at:nBytes.
 (b bitAnd:16r80) ~~ 0 ifTrue:[
-	"/ need another byte
+"/ need another byte
-	nBytes := nBytes + 1.
+nBytes := nBytes + 1.
-	t := ByteArray uninitializedNew:nBytes.
+t := ByteArray uninitializedNew:nBytes.
-	t replaceFrom:1 to:nBytes-1 with:digitByteArray startingAt:1.
+t replaceFrom:1 to:nBytes-1 with:digitByteArray startingAt:1.
-	t at:nBytes put:0.
+t at:nBytes put:0.
-	digitByteArray := t.
+digitByteArray := t.
 ].
 %{
 OBJ __digits = __INST(digitByteArray);
 if (__isByteArray(__digits)) {
-	int __nBytes = __intVal(nBytes);
+int __nBytes = __intVal(nBytes);
-	unsigned char *__bp = __ByteArrayInstPtr(__digits)->ba_element;
+unsigned char *__bp = __ByteArrayInstPtr(__digits)->ba_element;
-	unsigned INT __carry = 0, __newCarry;
+unsigned INT __carry = 0, __newCarry;
 #if defined(__LSBFIRST__)
 # if (__POINTER_SIZE__ == 8)
-	if (sizeof(unsigned INT) == 8) {
+if (sizeof(unsigned INT) == 8) {
-	    while (__nBytes >= 8) {
+while (__nBytes >= 8) {
-		unsigned INT __this;
+unsigned INT __this;
-		__this = ((unsigned INT *)__bp)[0];
+__this = ((unsigned INT *)__bp)[0];
-		__newCarry = (__this >> 63) /* & 1 */;
+__newCarry = (__this >> 63) /* & 1 */;
-		((unsigned INT *)__bp)[0] = (__this << 1) | __carry;
+((unsigned INT *)__bp)[0] = (__this << 1) | __carry;
-		__carry = __newCarry;
+__carry = __newCarry;
-		__bp += 8;
+__bp += 8;
-		__nBytes -= 8;
+__nBytes -= 8;
-	    }
+}
-	}
+}
 # endif
-	if (sizeof(unsigned int) == 4) {
+if (sizeof(unsigned int) == 4) {
-	    while (__nBytes >= 4) {
+while (__nBytes >= 4) {
-		unsigned int __this;
+unsigned int __this;
-		__this = ((unsigned int *)__bp)[0];
+__this = ((unsigned int *)__bp)[0];
-		__newCarry = (__this >> 31) /* & 1 */;
+__newCarry = (__this >> 31) /* & 1 */;
-		((unsigned int *)__bp)[0] = (__this << 1) | __carry;
+((unsigned int *)__bp)[0] = (__this << 1) | __carry;
-		__carry = __newCarry;
+__carry = __newCarry;
-		__bp += 4;
+__bp += 4;
-		__nBytes -= 4;
+__nBytes -= 4;
-	    }
+}
-	}
+}
-	if (__nBytes >= 2) {
+if (__nBytes >= 2) {
-	    unsigned short __this;
+unsigned short __this;
-	    __this = ((unsigned short *)__bp)[0];
+__this = ((unsigned short *)__bp)[0];
-	    __newCarry = (__this >> 15) /* & 1 */;
+__newCarry = (__this >> 15) /* & 1 */;
-	    ((unsigned short *)__bp)[0] = (__this << 1) | __carry;
+((unsigned short *)__bp)[0] = (__this << 1) | __carry;
-	    __carry = __newCarry;
+__carry = __newCarry;
-	    __bp += 2;
+__bp += 2;
-	    __nBytes -= 2;
+__nBytes -= 2;
-	}
+}
 #endif /* LSBFIRST */
-	while (__nBytes) {
+while (__nBytes) {
-	    unsigned char __this;
+unsigned char __this;
-	    __this = __bp[0];
+__this = __bp[0];
-	    __newCarry = (__this >> 7) /* & 1 */;
+__newCarry = (__this >> 7) /* & 1 */;
-	    __bp[0] = (__this << 1) | __carry;
+__bp[0] = (__this << 1) | __carry;
-	    __carry = __newCarry;
+__carry = __newCarry;
-	    __bp++;
+__bp++;
-	    __nBytes--;
+__nBytes--;
-	}
+}
-	RETURN (self);
+RETURN (self);
 }
 %}.
 prevBit := 0.
 1 to:digitByteArray size do:[:idx |
-	|thisByte|
+|thisByte|
-	thisByte := digitByteArray at:idx.
+thisByte := digitByteArray at:idx.
-	digitByteArray at:idx put:(((thisByte bitShift:1) bitAnd:16rFF) bitOr:prevBit).
+digitByteArray at:idx put:(((thisByte bitShift:1) bitAnd:16rFF) bitOr:prevBit).
-	prevBit := (thisByte bitShift:-7) bitAnd:1.
+prevBit := (thisByte bitShift:-7) bitAnd:1.
 ].
 "
 100000 asLargeInteger mul2
 16r7FFFFFFFFFFF copy mul2 hexPrintString

branch	jv
changeset 19137	199b5e15b1da
parent 19127	940613fe6659
parent 19135	e2d82660b855
child 19158	cdce727939ab