hg/stx-libbasic: comparison LargeInteger.st

equal deleted inserted replaced

-:fbfd2d411738
+:a74d669db937
 "
 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].
 "return the integer part of the quotient of the receivers value
 and the arguments value.
 The result is truncated toward negative infinity
 and will be negative, if the operands signs differ.
 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 -> -1 (because -(1/10) is truncated towards next smaller integer, which is -1.
+	-1 // 10 -> -1 (because -(1/10) is truncated towards next smaller integer, which is -1.
--10 // 3 -> -4 (because -(10/3) is truncated towards next smaller integer, which is -4.
+	-10 // 3 -> -4 (because -(10/3) is truncated towards next smaller integer, which is -4.
 See #quo: which returns -2 in the above case and #rem: which is the corresponding remainder."
 |cls divMod quo abs "{ Class: SmallInteger }" n|
 "
 this is the common case, dividing by a SmallInteger.
 Use a special method for this case ...
 "
 (cls == SmallInteger) ifTrue:[
-abs := aNumber.
+	abs := aNumber.
-abs := abs abs.
+	abs := abs abs.
-(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
+	(abs between:1 and:(SmallInteger maxBytes == 8 ifTrue:16r00ffffffffff ifFalse:16r00ffffff)) ifTrue:[
-divMod := self absFastDivMod:abs.
+	    divMod := self absFastDivMod:abs.
-] ifFalse:[
+	] ifFalse:[
-n := abs asLargeInteger.
+	    n := abs asLargeInteger.
-].
+	].
 ] ifFalse:[
-"
+	"
-if the argument is not a largeInteger, coerce
+	 if the argument is not a largeInteger, coerce
-"
+	"
-(cls == self class) ifFalse:[
+	(cls == self class) ifFalse:[
-^ self retry:#// coercing:aNumber
+	    ^ self retry:#// coercing:aNumber
-].
+	].
-n := aNumber
+	n := aNumber
 ].
 divMod isNil ifTrue:[
-divMod := self absDivMod:n.
+	divMod := self absDivMod:n.
 ].
 quo := divMod at:1.
 (sign == aNumber sign) ifFalse:[
-"/ adjust for truncation if negative and there is a remainder ...
+	"/ adjust for truncation if negative and there is a remainder ...
-"/ be careful: there is one special case to care for here:
+	"/ be careful: there is one special case to care for here:
-"/ if quo is maxInt+1, the negation can be represented as a smallInt.
+	"/ if quo is maxInt+1, the negation can be represented as a smallInt.
-quo := quo setSign:-1.
+	quo := quo setSign:-1.
-(divMod at:2) == 0 ifFalse:[
+	(divMod at:2) == 0 ifFalse:[
-^ quo - 1
+	    ^ quo - 1
-].
+	].
-quo digitLength == SmallInteger maxBytes ifTrue:[
+	quo digitLength == SmallInteger maxBytes ifTrue:[
-^ quo compressed
+	    ^ quo compressed
-].
+	].
 ].
 ^ quo
 "
 (9000000000 // 4000000000)   =   (900 // 400)   ifFalse:[self halt].
 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].
 "
 special case for SmallInteger minVal
 "
 sign == 1 ifTrue:[
-sz := digitByteArray size.
+	sz := digitByteArray size.
 %{
-int idx;
+#ifdef __SCHTEAM__
-unsigned char *bp;
+#else /* not SCHTEAM */
+	int idx;
-bp = (unsigned char *)(__ByteArrayInstPtr(__INST(digitByteArray))->ba_element);
+	unsigned char *bp;
-idx = __intVal(sz);
+	bp = (unsigned char *)(__ByteArrayInstPtr(__INST(digitByteArray))->ba_element);
-while ((idx > 1) && (bp[idx-1] == 0)) idx--;
+	idx = __intVal(sz);
-if (idx == sizeof(INT)) {
+	while ((idx > 1) && (bp[idx-1] == 0)) idx--;
-#if defined(__LSBFIRST__)
-# if __POINTER_SIZE__ == 8
+	if (idx == sizeof(INT)) {
-if ( ((unsigned INT *)bp)[0] == 0x4000000000000000L)
+# if defined(__LSBFIRST__)
+#  if __POINTER_SIZE__ == 8
+	    if ( ((unsigned INT *)bp)[0] == 0x4000000000000000L)
+#  else
+	    if ( ((unsigned INT *)bp)[0] == 0x40000000)
+#  endif
 # else
-if ( ((unsigned INT *)bp)[0] == 0x40000000)
+	    /*
+	     * generic code
+	     */
+	    if ((bp[idx-1] == 0x40)
+	     && (bp[idx-2] == 0)
+	     && (bp[idx-3] == 0)
+	     && (bp[idx-4] == 0)
+#  if __POINTER_SIZE__ == 8
+	     && (bp[idx-5] == 0)
+	     && (bp[idx-6] == 0)
+	     && (bp[idx-7] == 0)
+	     && (bp[idx-8] == 0)
+#  endif
+	    )
 # endif
-#else
+	    {
-/*
+		RETURN (__mkSmallInteger(_MIN_INT));
-* generic code
+	    }
-*/
+	}
-if ((bp[idx-1] == 0x40)
-&& (bp[idx-2] == 0)
-&& (bp[idx-3] == 0)
-&& (bp[idx-4] == 0)
-# if __POINTER_SIZE__ == 8
-&& (bp[idx-5] == 0)
-&& (bp[idx-6] == 0)
-&& (bp[idx-7] == 0)
-&& (bp[idx-8] == 0)
-# endif
-)
 #endif
-{
-RETURN (__mkSmallInteger(_MIN_INT));
-}
-}
 %}.
-"/      sz == 4 ifTrue:[
-"/        (digitByteArray at:1) == 0 ifTrue:[
+	sz == SmallInteger maxBytes ifTrue:[
-"/          (digitByteArray at:2) == 0 ifTrue:[
+	  (digitByteArray at:1) == 0 ifTrue:[
-"/            (digitByteArray at:3) == 0 ifTrue:[
+	   (digitByteArray at:2) == 0 ifTrue:[
-"/              (digitByteArray at:4) == 16r40 ifTrue:[
+	    (digitByteArray at:3) == 0 ifTrue:[
-"/                ^ SmallInteger minVal
+		SmallInteger maxBytes == 8 ifTrue:[
-"/              ].
+		  (digitByteArray at:4) == 0 ifTrue:[
-"/            ]
+		   (digitByteArray at:5) == 0 ifTrue:[
-"/          ]
+		    (digitByteArray at:6) == 0 ifTrue:[
-"/        ]
+		     (digitByteArray at:7) == 0 ifTrue:[
-"/      ]
+		      (digitByteArray at:8) == 16r40 ifTrue:[
+			^ SmallInteger minVal
+		      ].
+		     ]
+		    ]
+		   ]
+		  ]
+		] ifFalse:[
+		  (digitByteArray at:4) == 16r40 ifTrue:[
+		    ^ SmallInteger minVal
+		  ].
+		]
+	    ]
+	   ]
+	  ]
+	].
 ].
 "/ cg - can share the digits ...
 newNumber := self class digitBytes:digitByteArray sign:(sign negated).
 ^ newNumber
 !
 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
 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
 #ifdef __SCHTEAM__
 return context._RETURN( ((STLargeInteger)self).digitByteAt( index.intValue() ) );
 #endif
 %}.
 sign >= 0 ifTrue:[
-index > digitByteArray size ifTrue:[
+	index > digitByteArray size ifTrue:[
-^ 0
+	    ^ 0
-].
+	].
-^ digitByteArray at:index.
+	^ digitByteArray at:index.
 ].
 "/ negative int - do 2's complement here
 t := self bitInvert + 1.
 t setSign:1.
 digits := t digitBytes.
 index > digits size ifTrue:[
-^ 16rFF
+	^ 16rFF
 ].
 ^ digits at:index.
 "
 16r11111111111111111111 negated digitByteAt:1
 anInteger == 0 ifTrue:[^ 0].
 anInteger == 1 ifTrue:[^ self].
 num := anInteger abs.
 (num > 16r3FFFFF) ifTrue:[
-"if num is too big (so that multiplying by a byte could create a Large)"
+	"if num is too big (so that multiplying by a byte could create a Large)"
-^ anInteger retry:#* coercing:self
+	^ 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.
+		lResult := len + 6.
-]
+	    ]
-]
+	]
 ].
 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.
-*/
+	 */
-while ((_l >= sizeof(INT)) && (((unsigned INT *)digitP)[0] == 0)) {
+	while ((_l >= sizeof(INT)) && (((unsigned INT *)digitP)[0] == 0)) {
-((unsigned INT *)resultP)[0] = 0;
+	    ((unsigned INT *)resultP)[0] = 0;
-digitP += sizeof(INT);
+	    digitP += sizeof(INT);
-resultP += sizeof(INT);
+	    resultP += sizeof(INT);
-_l -= sizeof(INT);
+	    _l -= sizeof(INT);
-}
+	}
 #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 a 64bit int type ... good
+	     * have a 64bit int type ... good
-*/
+	     */
-UINT64 _prod64;
+	    UINT64 _prod64;
-/* have 64bit ints; can do it int-wise
+	    /* have 64bit ints; can do it int-wise
-*
+	     *
-* max: 0xFFFFFFFF * 0xFFFFFFFF -> 0xFFFFFFFE.0001
+	     * max: 0xFFFFFFFF * 0xFFFFFFFF -> 0xFFFFFFFE.0001
-* + maxCarry (0xFFFFFFFF)  -> 0xFFFFFFFF.0000
+	     * + maxCarry (0xFFFFFFFF)  -> 0xFFFFFFFF.0000
-*/
+	     */
-while (_l > 3) {
+	    while (_l > 3) {
-unsigned __t;
+		unsigned __t;
-__t = ((unsigned *)digitP)[0];
+		__t = ((unsigned *)digitP)[0];
-digitP += 4;
+		digitP += 4;
-_prod64 = (INT64)_v;
+		_prod64 = (INT64)_v;
-_prod64 *= __t;
+		_prod64 *= __t;
-_prod64 += _carry;
+		_prod64 += _carry;
-((unsigned *)resultP)[0] = _prod64 /* & 0xFFFFFFFFL */;
+		((unsigned *)resultP)[0] = _prod64 /* & 0xFFFFFFFFL */;
-_carry = _prod64 >> 32;
+		_carry = _prod64 >> 32;
-resultP += 4;
+		resultP += 4;
-_l -= 4;
+		_l -= 4;
-}
+	    }
-if (_l > 1) {
+	    if (_l > 1) {
-unsigned short __t;
+		unsigned short __t;
-__t = ((unsigned short *)digitP)[0];
+		__t = ((unsigned short *)digitP)[0];
-digitP += 2;
+		digitP += 2;
-_prod64 = (INT64)_v;
+		_prod64 = (INT64)_v;
-_prod64 *= __t;
+		_prod64 *= __t;
-_prod64 += _carry;
+		_prod64 += _carry;
-((unsigned short *)resultP)[0] = _prod64 /* & 0xFFFF */;
+		((unsigned short *)resultP)[0] = _prod64 /* & 0xFFFF */;
-_carry = _prod64 >> 16;
+		_carry = _prod64 >> 16;
-resultP += 2;
+		resultP += 2;
-_l -= 2;
+		_l -= 2;
-}
+	    }
-if (_l > 0) {
+	    if (_l > 0) {
-_prod64 = *digitP++ * _v + _carry;
+		_prod64 = *digitP++ * _v + _carry;
-*resultP++ = _prod64 /* & 0xFF */;
+		*resultP++ = _prod64 /* & 0xFF */;
-_carry = _prod64 >> 8;
+		_carry = _prod64 >> 8;
-_l--;
+		_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
 "/ 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"
 len1 := digitByteArray size.
 otherDigitByteArray := aLargeInteger digitBytes.
 len2 := otherDigitByteArray size.
 len1 > len2 ifTrue:[
-lResult := len1
+	lResult := len1
 ] ifFalse:[
-lResult := (len1 max: len2) + 1.
+	lResult := (len1 max: len2) + 1.
 ].
 result := self class basicNew numberOfDigits:lResult sign:newSign.
 resultDigitByteArray := result digitBytes.
 lastDigit := 0.
 OBJ _digitByteArray = __INST(digitByteArray);
 if (__isByteArray(_digitByteArray)
 && __isByteArray(otherDigitByteArray)
 && __isByteArray(resultDigitByteArray)) {
-int __len1 = __intVal(len1);
+	int __len1 = __intVal(len1);
-int __len2 = __intVal(len2);
+	int __len2 = __intVal(len2);
-int __minLen = __len1 < __len2 ? __len1 : __len2;
+	int __minLen = __len1 < __len2 ? __len1 : __len2;
-int __index, __borrow = 0;
+	int __index, __borrow = 0;
-INT __diff;
+	INT __diff;
-unsigned char *__myDigits, *__otherDigits, *__resultDigits;
+	unsigned char *__myDigits, *__otherDigits, *__resultDigits;
-ok = true;
+	ok = true;
-__resultDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
+	__resultDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
-__otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
+	__otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
-__myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+	__myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-__index = 1;
+	__index = 1;
 #if defined(__LSBFIRST__)
 # if __POINTER_SIZE__ == 8
-/*
+	/*
-* subtract int-wise
+	 * subtract int-wise
-*/
+	 */
-while ((__index+3) <= __minLen) {
+	while ((__index+3) <= __minLen) {
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__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 *)(__resultDigits+__index-1))[0] = __diff;
+	    ((unsigned int *)(__resultDigits+__index-1))[0] = __diff;
-__index += 4;
+	    __index += 4;
-}
+	}
 # endif /* 64bit */
-/*
+	/*
-* subtract short-wise
+	 * subtract short-wise
-*/
+	 */
-while (__index < __minLen) {   /* i.e. index+1 <= minLen */
+	while (__index < __minLen) {   /* i.e. index+1 <= minLen */
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__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 *)(__resultDigits+__index-1))[0] = __diff;
+	    ((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+	    __index += 2;
-}
+	}
-if (__index == __minLen) {
+	if (__index == __minLen) {
-/* one of the operands has odd length - cannot continue short-wise */
+	    /* one of the operands has odd length - cannot continue short-wise */
-} else {
+	} else {
-if (__len1 > __len2) {
+	    if (__len1 > __len2) {
-while (__index < __len1) {
+		while (__index < __len1) {
-/* do not make this into one expression - ask cg why */
+		    /* do not make this into one expression - ask cg why */
-__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 *)(__resultDigits+__index-1))[0] = __diff;
+			((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+			__index += 2;
-/* copy over rest */
+			/* copy over rest */
-while (__index < __len1) {
+			while (__index < __len1) {
-((unsigned short *)(__resultDigits+__index-1))[0] = ((unsigned short *)(__myDigits+__index-1))[0];
+			    ((unsigned short *)(__resultDigits+__index-1))[0] = ((unsigned short *)(__myDigits+__index-1))[0];
-__index+=2;
+			    __index+=2;
-}
+			}
-if (__index <= __len1) {
+			if (__index <= __len1) {
-__resultDigits[__index-1] = __myDigits[__index-1];
+			    __resultDigits[__index-1] = __myDigits[__index-1];
-__index++;
+			    __index++;
-}
+			}
-break;
+			break;
-}
+		    }
-__borrow = 1;
+		    __borrow = 1;
-/* __diff += 0x10000; */
+		    /* __diff += 0x10000; */
-((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
+		    ((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+		    __index += 2;
-}
+		}
-} else {
+	    } else {
-if (__len2 > __len1) {
+		if (__len2 > __len1) {
-while (__index < __len2) {
+		    while (__index < __len2) {
-/* do not make this into one expression - ask cg why */
+			/* do not make this into one expression - ask cg why */
-__diff = 0;
+			__diff = 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 *)(__resultDigits+__index-1))[0] = __diff;
+			((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+			__index += 2;
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 #endif
-/*
+	/*
-* subtract byte-wise
+	 * subtract byte-wise
-*/
+	 */
-while (__index <= __minLen) {
+	while (__index <= __minLen) {
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__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; */
-}
+	    }
-__resultDigits[__index-1] = __diff;
+	    __resultDigits[__index-1] = __diff;
-__index++;
+	    __index++;
-}
+	}
-if (__len1 > __len2) {
+	if (__len1 > __len2) {
-while (__index <= __len1) {
+	    while (__index <= __len1) {
-/* do not make this into one expression - ask cg why */
+		/* do not make this into one expression - ask cg why */
-__diff = __myDigits[__index-1];
+		__diff = __myDigits[__index-1];
-__diff -= __borrow;
+		__diff -= __borrow;
-if (__diff >= 0) {
+		if (__diff >= 0) {
-__borrow = 0;
+		    __borrow = 0;
-/* copy over rest */
+		    /* copy over rest */
-__resultDigits[__index-1] = __diff;
+		    __resultDigits[__index-1] = __diff;
-__index++;
+		    __index++;
-while (__index <= __len1) {
+		    while (__index <= __len1) {
-__resultDigits[__index-1] = __myDigits[__index-1];
+			__resultDigits[__index-1] = __myDigits[__index-1];
-__index++;
+			__index++;
-}
+		    }
-break;
+		    break;
-}
+		}
-__borrow = 1;
+		__borrow = 1;
-/* __diff += 0x100; */
+		/* __diff += 0x100; */
-__resultDigits[__index-1] = __diff;
+		__resultDigits[__index-1] = __diff;
-__index++;
+		__index++;
-}
+	    }
-} else {
+	} else {
-if (__len2 > __len1) {
+	    if (__len2 > __len1) {
-while (__index <= __len2) {
+		while (__index <= __len2) {
-/* do not make this into one expression - ask cg why */
+		    /* do not make this into one expression - ask cg why */
-__diff = 0;
+		    __diff = 0;
-__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; */
-}
+		    }
-__resultDigits[__index-1] = __diff;
+		    __resultDigits[__index-1] = __diff;
-__index++;
+		    __index++;
-}
+		}
-}
+	    }
-}
+	}
-borrow = __mkSmallInteger(__borrow);
+	borrow = __mkSmallInteger(__borrow);
-index = __mkSmallInteger(__index);
+	index = __mkSmallInteger(__index);
-lastDigit = __mkSmallInteger(__resultDigits[__intVal(lResult)-1]);
+	lastDigit = __mkSmallInteger(__resultDigits[__intVal(lResult)-1]);
 }
 %}.
 ok == true ifFalse:[
-index := 1.
+	index := 1.
-borrow := 0.
+	borrow := 0.
-done := false.
+	done := false.
-[done] whileFalse:[
+	[done] whileFalse:[
-diff := borrow.
+	    diff := borrow.
-(index <= len1) ifTrue:[
+	    (index <= len1) ifTrue:[
-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)
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
-(index <= len2) ifTrue:[
+		(index <= len2) ifTrue:[
-diff := diff - (otherDigitByteArray basicAt:index)
+		    diff := diff - (otherDigitByteArray basicAt:index)
-] ifFalse:[
+		] ifFalse:[
-"end reached"
+		    "end reached"
-done := true
+		    done := true
-]
+		]
-].
+	    ].
-"/ 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:[
 "/            borrow := -1.
 "/            diff := diff + 16r100
 "/        ] ifFalse:[
 "/            borrow := 0
 "/        ].
-resultDigitByteArray basicAt:index put:diff.
+	    resultDigitByteArray basicAt:index put:diff.
-index := index + 1
+	    index := index + 1
-].
+	].
-lastDigit := resultDigitByteArray basicAt:lResult.
+	lastDigit := resultDigitByteArray basicAt:lResult.
 ].
 (borrow ~~ 0) ifTrue:[
-"/ must generate 255's complement
+	"/ must generate 255's complement
-result sign:newSign negated.
+	result sign:newSign negated.
-[index <= lResult] whileTrue:[
+	[index <= lResult] whileTrue:[
-resultDigitByteArray basicAt:index put:16rFF.
+	    resultDigitByteArray basicAt:index put:16rFF.
-index := index + 1.
+	    index := index + 1.
-].
+	].
-index := lResult.
+	index := lResult.
-[index > 0] whileTrue:[
+	[index > 0] whileTrue:[
-resultDigitByteArray basicAt:index put:(255 - (resultDigitByteArray at:index)).
+	    resultDigitByteArray basicAt:index put:(255 - (resultDigitByteArray at:index)).
-index := index - 1.
+	    index := index - 1.
-].
+	].
-index := 1.
+	index := 1.
-carry := 1.
+	carry := 1.
-[carry ~~ 0] whileTrue:[
+	[carry ~~ 0] whileTrue:[
-(index <= lResult) ifTrue:[
+	    (index <= lResult) ifTrue:[
-carry := (resultDigitByteArray basicAt:index) + carry.
+		carry := (resultDigitByteArray basicAt:index) + carry.
-].
+	    ].
-resultDigitByteArray basicAt:index put:(carry bitAnd:16rFF).
+	    resultDigitByteArray basicAt:index put:(carry bitAnd:16rFF).
-carry := carry bitShift:-8.
+	    carry := carry bitShift:-8.
-index := index + 1
+	    index := index + 1
-].
+	].
-lastDigit := resultDigitByteArray basicAt:lResult.
+	lastDigit := resultDigitByteArray basicAt:lResult.
 ].
 (lastDigit == 0 or:[lResult <= SmallInteger maxBytes]) ifTrue:[
-^ result compressed.
+	^ result compressed.
 ].
 ^ result
 "Modified: 5.11.1996 / 14:09:25 / cg"
 !
 %{
 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"
 ! !
 !LargeInteger class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.226 2015-05-20 16:01:28 cg Exp $'
+^ '$Header$'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.226 2015-05-20 16:01:28 cg Exp $'
+^ '$Header$'
 ! !

branch	jv
changeset 18630	a74d669db937
parent 18383	3a40da3624b7
parent 18621	78b4a4b916a5
child 18710	c0a0e0b57e59