hg/stx-libbasic: comparison SmallInteger.st

equal deleted inserted replaced

-:d6c7cb1e32df
+:5d56805b999a
 "{ Encoding: utf8 }"
 "
 COPYRIGHT (c) 1988 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:#SmallInteger
-	instanceVariableNames:''
+instanceVariableNames:''
-	classVariableNames:'ZeroString'
+classVariableNames:'ZeroString'
-	poolDictionaries:''
+poolDictionaries:''
-	category:'Magnitude-Numbers'
+category:'Magnitude-Numbers'
 !
 !SmallInteger primitiveDefinitions!
 %{
 #include <stdio.h>
 !SmallInteger class methodsFor:'documentation'!
 copyright
 "
 COPYRIGHT (c) 1988 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
 documentation
 "
 SmallIntegers are Integers in the range of at least +/- 2^30
 i.e. 31 bits, but this is not a guaranteed:
-	on an alpha or x86_64, 63 bits are used, if the system was configured for 64bit mode.
+on an alpha or x86_64, 63 bits are used, if the system was configured for 64bit mode.
-	under the Schteam-VM, 64 bits are used (i.e. a full long integer)
+under the Schteam-VM, 64 bits are used (i.e. a full long integer)
 These are no real objects - they have no instances (not even storage !!)
 and cannot be subclassed.
 The reason is to save both storage and runtime by not collecting
 SmallIntegers in the system. SmallInts are marked by having the TAG_INT
 If you really need this kind of thing, create a subclass of Integer,
 with an instance variable holding the value.
 [author:]
-	Claus Gittinger
+Claus Gittinger
 [see also:]
-	Number
+Number
-	Float Fraction FixedPoint
+Float Fraction FixedPoint
-	LargeInteger
+LargeInteger
 "
 ! !
 !SmallInteger class methodsFor:'instance creation'!
 bitMaskFor:index
 "return a bitmask for the index's bit (index starts at 1)"
 (index between:1 and:SmallInteger maxBits) ifFalse:[
-	^ SubscriptOutOfBoundsSignal
+^ SubscriptOutOfBoundsSignal
-		raiseRequestWith:index
+raiseRequestWith:index
-		errorString:'index out of bounds'
+errorString:'index out of bounds'
 ].
 ^ 1 bitShift:(index - 1)
 ! !
 !SmallInteger class methodsFor:'class initialization'!
 # if defined(__i386__) && defined(__GNUC__) && (__GNUC__ >= 2)
 #  define USE_LONGLONG_FOR_MUL
 # endif
 if (__isSmallInteger(aNumber)) {
-	otherValue = __intVal(aNumber);
+otherValue = __intVal(aNumber);
 # if defined(USE_LONGLONG_FOR_MUL)
-	{
+{
 #  if defined(__alpha__) && !defined(__alpha64__)
 #   define LONGLONG      INT64
 #  else
 #   define LONGLONG      long long
 #  endif
-	    LONGLONG product;
+LONGLONG product;
-	    product = (LONGLONG)myValue * (LONGLONG)otherValue;
+product = (LONGLONG)myValue * (LONGLONG)otherValue;
-	    if ((product >= (LONGLONG)_MIN_INT)
+if ((product >= (LONGLONG)_MIN_INT)
-	     && (product <= (LONGLONG)_MAX_INT)) {
+&& (product <= (LONGLONG)_MAX_INT)) {
-		RETURN ( __mkSmallInteger((INT)product) );
+RETURN ( __mkSmallInteger((INT)product) );
-	    }
+}
-	    if (product < 0) {
+if (product < 0) {
-		negative = -1;
+negative = -1;
-		product = -product;
+product = -product;
-	    } else {
+} else {
-		negative = 1;
+negative = 1;
-	    }
+}
-	    productHi = product >> 32;
+productHi = product >> 32;
-	    productLow = product & 0xFFFFFFFFLL;
+productLow = product & 0xFFFFFFFFLL;
-	}
+}
 # else /* no long-long */
-	negative = 1;
+negative = 1;
-	if (myValue < 0) {
+if (myValue < 0) {
-	    negative = -1;
+negative = -1;
-	    myValue = -myValue;
+myValue = -myValue;
-	}
+}
-	if (otherValue < 0) {
+if (otherValue < 0) {
-	    negative = -negative;
+negative = -negative;
-	    otherValue = -otherValue;
+otherValue = -otherValue;
-	}
+}
 #  if defined(__GNUC__) && defined(__mc68k__)
-	asm ("mulu%.l %3,%1:%0"
+asm ("mulu%.l %3,%1:%0"
-		: "=d"  ((unsigned long)(productLow)),
+: "=d"  ((unsigned long)(productLow)),
-		  "=d"  ((unsigned long)(productHi))
+"=d"  ((unsigned long)(productHi))
-		: "%0"  ((unsigned long)(myValue)),
+: "%0"  ((unsigned long)(myValue)),
-		  "dmi" ((unsigned long)(otherValue)));
+"dmi" ((unsigned long)(otherValue)));
 #  else
 #   if defined (__GNUC__) && defined(__x86__)
-	asm ("mull %3"
+asm ("mull %3"
-		: "=a"  ((unsigned long)(productLow)),
+: "=a"  ((unsigned long)(productLow)),
-		  "=d"  ((unsigned long)(productHi))
+"=d"  ((unsigned long)(productHi))
-		: "%0"  ((unsigned long)(myValue)),
+: "%0"  ((unsigned long)(myValue)),
-		  "rm"  ((unsigned long)(otherValue)));
+"rm"  ((unsigned long)(otherValue)));
 #   else
 #    if defined(__win32__) && defined(__BORLANDC__)
-	asm {
+asm {
-	    mov   eax, myValue
+mov   eax, myValue
-	    mov   edx, otherValue
+mov   edx, otherValue
-	    mul   edx
+mul   edx
-	    mov   productLow, eax
+mov   productLow, eax
-	    mov   productHi, edx
+mov   productHi, edx
-	}
+}
 #    else /* generic */
-	{
+{
-	    unsigned INT pHH, pHL, pLH, pLL;
+unsigned INT pHH, pHL, pLH, pLL;
-	    unsigned INT low1, low2, hi1, hi2;
+unsigned INT low1, low2, hi1, hi2;
-	    unsigned INT t;
+unsigned INT t;
-	    /* unsigned multiply myValue * otherValue -> productHi, productLow
+/* unsigned multiply myValue * otherValue -> productHi, productLow
-	     *
+*
-	     * this is too slow:
+* this is too slow:
-	     * since most machines can do 32*32 to 64 bit multiply,
+* since most machines can do 32*32 to 64 bit multiply,
-	     * (or at least 32*32 with Overflow check)
+* (or at least 32*32 with Overflow check)
-	     * - need more assembler (inline) functions here
+* - need more assembler (inline) functions here
-	     */
+*/
 #     if __POINTER_SIZE__ == 8
-	    low1 = low32Bits((unsigned INT)myValue);
+low1 = low32Bits((unsigned INT)myValue);
-	    hi1 = hi32Bits((unsigned INT)myValue);
+hi1 = hi32Bits((unsigned INT)myValue);
-	    low2 = low32Bits((unsigned INT)otherValue);
+low2 = low32Bits((unsigned INT)otherValue);
-	    hi2 = hi32Bits((unsigned INT)otherValue);
+hi2 = hi32Bits((unsigned INT)otherValue);
 #      define LLMASK 0xC000000000000000LL
 #     else
-	    low1 = low16Bits((unsigned INT)myValue);
+low1 = low16Bits((unsigned INT)myValue);
-	    hi1 = hi16Bits((unsigned INT)myValue);
+hi1 = hi16Bits((unsigned INT)myValue);
-	    low2 = low16Bits((unsigned INT)otherValue);
+low2 = low16Bits((unsigned INT)otherValue);
-	    hi2 = hi16Bits((unsigned INT)otherValue);
+hi2 = hi16Bits((unsigned INT)otherValue);
 #      define LLMASK 0xC0000000L
 #     endif
-	    pLH = low1 * hi2;
+pLH = low1 * hi2;
-	    pHL = hi1 * low2;
+pHL = hi1 * low2;
-	    pLL = low1 * low2;
+pLL = low1 * low2;
-	    pHH = hi1 * hi2;
+pHH = hi1 * hi2;
-	    /*
+/*
-	     * the common case ...
+* the common case ...
-	     */
+*/
-	    if ((pHL == 0)
+if ((pHL == 0)
-	     && (pLH == 0)
+&& (pLH == 0)
-	     && (pHH == 0)
+&& (pHH == 0)
-	     && ((pLL & LLMASK) == 0)) {
+&& ((pLL & LLMASK) == 0)) {
-		if (negative < 0) {
+if (negative < 0) {
-		    RETURN ( __mkSmallInteger(- ((INT)pLL)) );
+RETURN ( __mkSmallInteger(- ((INT)pLL)) );
-		}
+}
-		RETURN ( __mkSmallInteger((INT)pLL) );
+RETURN ( __mkSmallInteger((INT)pLL) );
-	    }
+}
-	    /*
+/*
-	     *   pHH |--------|--------|
+*   pHH |--------|--------|
-	     *   pLH          |--------|--------|
+*   pLH          |--------|--------|
-	     *   pHL          |--------|--------|
+*   pHL          |--------|--------|
-	     *   pLL                   |--------|--------|
+*   pLL                   |--------|--------|
-	     */
+*/
 #     if __POINTER_SIZE__ == 8
-	    t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
+t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
-	    productLow = (t << 32) + low32Bits(pLL);
+productLow = (t << 32) + low32Bits(pLL);
-	    productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
+productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
 #     else
-	    t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
+t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
-	    productLow = (t << 16) + low16Bits(pLL);
+productLow = (t << 16) + low16Bits(pLL);
-	    productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
+productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
 #     endif
-	}
+}
 #    endif /* ! __win32__ */
 #   endif /* ! (__GNUC__ && __x86__) */
 #  endif /* ! (__GNUC__ && __mc68k__) */
-	if (productHi == 0) {
+if (productHi == 0) {
-	    if (negative < 0) {
+if (negative < 0) {
-		if (productLow <= -(_MIN_INT)) {
+if (productLow <= -(_MIN_INT)) {
-		    RETURN ( __mkSmallInteger(-((INT)productLow)) );
+RETURN ( __mkSmallInteger(-((INT)productLow)) );
-		}
+}
-	    } else {
+} else {
-		if (productLow <= _MAX_INT) {
+if (productLow <= _MAX_INT) {
-		    RETURN ( __mkSmallInteger(productLow) );
+RETURN ( __mkSmallInteger(productLow) );
-		}
+}
-	    }
+}
-	}
+}
 # endif /* ! USE_LONGLONG */
 # if __POINTER_SIZE__ == 8
-	RETURN (__MKLARGEINT128(negative, productLow, productHi));
+RETURN (__MKLARGEINT128(negative, productLow, productHi));
 # else
-	RETURN (__MKLARGEINT64(negative, productLow, productHi));
+RETURN (__MKLARGEINT64(negative, productLow, productHi));
 # endif
 } else if (__isFloatLike(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	double val = (double)myValue * __floatVal(aNumber);
+double val = (double)myValue * __floatVal(aNumber);
-	__qMKFLOAT(newFloat, val);
+__qMKFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 } else if (__isShortFloat(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	float val = (float)myValue * __shortFloatVal(aNumber);
+float val = (float)myValue * __shortFloatVal(aNumber);
-	__qMKSFLOAT(newFloat, val);
+__qMKSFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 } else if (__isFractionLike(aNumber)) {
-	OBJ t = __FractionInstPtr(aNumber)->f_numerator;
+OBJ t = __FractionInstPtr(aNumber)->f_numerator;
-	if (myValue == 0) {
+if (myValue == 0) {
-	    RETURN(__mkSmallInteger(0));
+RETURN(__mkSmallInteger(0));
-	}
+}
-	if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-	    INT num = __intVal(t);
+INT num = __intVal(t);
-	    t = __FractionInstPtr(aNumber)->f_denominator;
+t = __FractionInstPtr(aNumber)->f_denominator;
-	    if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-		INT prod = myValue * num;
+INT prod = myValue * num;
-		if (prod / myValue == num) { // check for overflow
+if (prod / myValue == num) { // check for overflow
-		    INT den = __intVal(t);
+INT den = __intVal(t);
-		    INT quo = prod / den;
+INT quo = prod / den;
-		    if (quo * den == prod) {        // check for integer result
+if (quo * den == prod) {        // check for integer result
-			RETURN ( __mkSmallInteger(quo) );
+RETURN ( __mkSmallInteger(quo) );
-		    }
+}
-		}
+}
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ aNumber productFromInteger:self
 "
-	3 * (1/2)
+3 * (1/2)
-	6 * (1/2)
+6 * (1/2)
-	6 * (-1/2)
+6 * (-1/2)
 "
 !
 + aNumber
 "return the sum of the receiver's value and the argument's value"
 * (see the message send at the bottom)
 */
 if (__isSmallInteger(aNumber)) {
 # ifdef _ADD_IO_IO
-	RETURN ( _ADD_IO_IO(self, aNumber) );
+RETURN ( _ADD_IO_IO(self, aNumber) );
 # else
-	REGISTER INT sum;
+REGISTER INT sum;
-	sum =  __intVal(self) + __intVal(aNumber);
+sum =  __intVal(self) + __intVal(aNumber);
-	if (__ISVALIDINTEGER(sum)) {
+if (__ISVALIDINTEGER(sum)) {
-	    RETURN ( __mkSmallInteger(sum) );
+RETURN ( __mkSmallInteger(sum) );
-	}
+}
-	RETURN ( __MKLARGEINT(sum) );
+RETURN ( __MKLARGEINT(sum) );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	double val = (double)__intVal(self) + __floatVal(aNumber);
+double val = (double)__intVal(self) + __floatVal(aNumber);
-	__qMKFLOAT(newFloat, val);
+__qMKFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 }
 if (__isShortFloat(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	float val = (float)__intVal(self) + __shortFloatVal(aNumber);
+float val = (float)__intVal(self) + __shortFloatVal(aNumber);
-	__qMKSFLOAT(newFloat, val);
+__qMKSFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ aNumber sumFromInteger:self
 !
 * (see the message send at the bottom)
 */
 if (__isSmallInteger(aNumber)) {
 # ifdef _SUB_IO_IO
-	RETURN ( _SUB_IO_IO(self, aNumber) );
+RETURN ( _SUB_IO_IO(self, aNumber) );
 # else
-	REGISTER INT diff =  __intVal(self) - __intVal(aNumber);
+REGISTER INT diff =  __intVal(self) - __intVal(aNumber);
-	if (__ISVALIDINTEGER(diff)) {
+if (__ISVALIDINTEGER(diff)) {
-	    RETURN ( __mkSmallInteger(diff) );
+RETURN ( __mkSmallInteger(diff) );
-	}
+}
-	RETURN ( __MKLARGEINT(diff) );
+RETURN ( __MKLARGEINT(diff) );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	double val = (double)__intVal(self) - __floatVal(aNumber);
+double val = (double)__intVal(self) - __floatVal(aNumber);
-	__qMKFLOAT(newFloat, val);
+__qMKFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 }
 if (__isShortFloat(aNumber)) {
-	OBJ newFloat;
+OBJ newFloat;
-	float val = (float)__intVal(self) - __shortFloatVal(aNumber);
+float val = (float)__intVal(self) - __shortFloatVal(aNumber);
-	__qMKSFLOAT(newFloat, val);
+__qMKSFLOAT(newFloat, val);
-	RETURN ( newFloat );
+RETURN ( newFloat );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ aNumber differenceFromInteger:self
 !
 INT t, val;
 double dval;
 INT myValue = __intVal(self);
 if (__isSmallInteger(aNumber)) {
-	val = __intVal(aNumber);
+val = __intVal(aNumber);
-	if (val != 0) {
+if (val != 0) {
-	    t = myValue / val;
+t = myValue / val;
 # ifdef GOOD_OPTIMIZER
-	    if (myValue % val == 0) {
+if (myValue % val == 0) {
 # else
-	    /* this is stupid - all I want is to look for a remainder ...
+/* this is stupid - all I want is to look for a remainder ...
-	       but most compilers are too stupid and generate an extra modulus
+but most compilers are too stupid and generate an extra modulus
-	       instruction for "if (me % val)".
+instruction for "if (me % val)".
-	       Even if most divide instructions already leave the remainder in
+Even if most divide instructions already leave the remainder in
-	       some register.
+some register.
-	       Therefore I use a multiplication which is faster than a modulo
+Therefore I use a multiplication which is faster than a modulo
-	       on most machines. Hint to GNU people :-)
+on most machines. Hint to GNU people :-)
-	    */
+*/
-	    if ((t * val) == myValue) {
+if ((t * val) == myValue) {
 # endif
-		RETURN ( __mkSmallInteger(t) );
+RETURN ( __mkSmallInteger(t) );
-	    }
+}
-	}
+}
 } else {
-	if (__isFloatLike(aNumber)) {
+if (__isFloatLike(aNumber)) {
-	    dval = __floatVal(aNumber);
+dval = __floatVal(aNumber);
-	    if (dval != 0.0) {
+if (dval != 0.0) {
-		OBJ newFloat;
+OBJ newFloat;
-		double val = (double)myValue / dval;
+double val = (double)myValue / dval;
-		__qMKFLOAT(newFloat, val);
+__qMKFLOAT(newFloat, val);
-		RETURN ( newFloat );
+RETURN ( newFloat );
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 aNumber isInteger ifTrue:[
-	aNumber == 0 ifTrue:[
+aNumber == 0 ifTrue:[
-	    ^ ZeroDivide raiseRequestWith:thisContext.
+^ ZeroDivide raiseRequestWith:thisContext.
-	].
+].
-	^ Fraction numerator:self denominator:aNumber
+^ Fraction numerator:self denominator:aNumber
 ].
 ^ aNumber quotientFromInteger:self
 "
 8 / 4
 "return the integer part of the quotient of the receiver's value
 and the argument's 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:
+Especially surprising (because of truncation toward negative infinity):
-	-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."
+See #quo: which truncates toward zero and returns -2 in the above case
+and #rem: which is the corresponding remainder."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 return context._RETURN( self.quotientTruncated( aNumber ));
 #else
 INT divisor, rslt;
 INT dividend = __intVal(self);
 if (__isSmallInteger(aNumber)) {
-	divisor = __intVal(aNumber);
+divisor = __intVal(aNumber);
-	if (divisor != 0) {
+if (divisor != 0) {
-	    rslt = dividend / divisor;
+rslt = dividend / divisor;
-	    /*
+/*
-	     * Optimized to speed up positive result
+* Optimized to speed up positive result
-	     */
+*/
-	    if (rslt <= 0) {
+if (rslt <= 0) {
-		if (rslt == 0) {
+if (rslt == 0) {
-		    if ((dividend ^ divisor) < 0) {
+if ((dividend ^ divisor) < 0) {
-			/*
+/*
-			 * result (negative) has been truncated toward 0.
+* result (negative) has been truncated toward 0.
-			 * Return -1, because we truncate toward negative inf.
+* Return -1, because we truncate toward negative inf.
-			 */
+*/
-			 rslt = -1;
+rslt = -1;
-		    }
+}
-		} else {
+} else {
-		    /*
+/*
-		     * If result (negative) has been truncated toward 0,
+* If result (negative) has been truncated toward 0,
-		     * subtract 1, because we truncate toward negative inf.
+* subtract 1, because we truncate toward negative inf.
-		     */
+*/
-		    if (divisor > 0) {
+if (divisor > 0) {
-			if (rslt * divisor > dividend) {
+if (rslt * divisor > dividend) {
-			    rslt--;
+rslt--;
-			}
+}
-		    } else {
+} else {
-			if (rslt * divisor < dividend) {
+if (rslt * divisor < dividend) {
-			    rslt--;
+rslt--;
-			}
+}
-		    }
+}
-		}
+}
-	    }
+}
-	    RETURN ( __mkSmallInteger(rslt) );
+RETURN ( __mkSmallInteger(rslt) );
-	}
+}
 } else {
-	if (__isFractionLike(aNumber)) {
+if (__isFractionLike(aNumber)) {
-	    OBJ t = __FractionInstPtr(aNumber)->f_numerator;
+OBJ t = __FractionInstPtr(aNumber)->f_numerator;
-	    if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-		INT num = __intVal(t);
+INT num = __intVal(t);
-		t = __FractionInstPtr(aNumber)->f_denominator;
+t = __FractionInstPtr(aNumber)->f_denominator;
-		if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-		    INT den = __intVal(t);
+INT den = __intVal(t);
-		    INT prod;
+INT prod;
 #if 0 && defined(__GNUC__) // supported from GCC 5
-		    if (!__builtin_mul_overflow(myself, den, &prod)) {
+if (!__builtin_mul_overflow(myself, den, &prod)) {
-			goto out;   // overflow, try harder...
+goto out;   // overflow, try harder...
-		    }
+}
 #else
-		    prod = dividend * den;
+prod = dividend * den;
-		    // make sure, that no overflow occurred
+// make sure, that no overflow occurred
-		    if (prod / den != dividend) {
+if (prod / den != dividend) {
-			goto out;   // overflow, try harder...
+goto out;   // overflow, try harder...
-		    }
+}
 #endif
-		    rslt = prod / num;
+rslt = prod / num;
-		    /*
+/*
-		     * Optimized to speed up positive result
+* Optimized to speed up positive result
-		     */
+*/
-		    if (rslt <= 0) {
+if (rslt <= 0) {
-			if (rslt == 0) {
+if (rslt == 0) {
-			    if ((dividend ^ num) < 0) {
+if ((dividend ^ num) < 0) {
-				/*
+/*
-				 * result (negative) has been truncated toward 0.
+* result (negative) has been truncated toward 0.
-				 * Return -1, because we truncate toward negative inf.
+* Return -1, because we truncate toward negative inf.
-				 */
+*/
-				 rslt = -1;
+rslt = -1;
-			    }
+}
-			} else {
+} else {
-			    /*
+/*
-			     * If result (negative) has been truncated toward 0,
+* If result (negative) has been truncated toward 0,
-			     * subtract 1, because we truncate toward negative inf.
+* subtract 1, because we truncate toward negative inf.
-			     */
+*/
-			    if (num > 0) {
+if (num > 0) {
-				if (rslt * num > prod) rslt--;
+if (rslt * num > prod) rslt--;
-			    } else {
+} else {
-				if (rslt * num < prod) rslt--;
+if (rslt * num < prod) rslt--;
-			    }
+}
-			}
+}
-		    }
+}
-		    RETURN ( __mkSmallInteger(rslt) );
+RETURN ( __mkSmallInteger(rslt) );
-		}
+}
-	    }
+}
-	}
+}
 }
 out:;
 #endif /* not __SCHTEAM__ */
 %}.
 (aNumber = 0) ifTrue:[
-	^ ZeroDivide raiseRequestWith:thisContext.
+^ ZeroDivide raiseRequestWith:thisContext.
 ].
 ^ aNumber integerQuotientFromInteger:self
 "
 9 // 4     ~~ 2 ifTrue:[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."
 */
 INT dividend, divisor, rem;
 if (__isSmallInteger(aNumber)
-	&& (divisor = __intVal(aNumber)) != 0) {
+&& (divisor = __intVal(aNumber)) != 0) {
-	/*
+/*
-	 * Note that the sign of something modulo a negative number is undefined
+* Note that the sign of something modulo a negative number is undefined
-	 * in C!
+* in C!
-	 */
+*/
-	dividend = __intVal(self);
+dividend = __intVal(self);
-	rem = dividend % divisor;
+rem = dividend % divisor;
-	if (rem) {
+if (rem) {
-	    if ((rem ^ divisor) < 0) {
+if ((rem ^ divisor) < 0) {
-		/* sign of remainder is different from sign of divisor */
+/* sign of remainder is different from sign of divisor */
-		rem = -rem;
+rem = -rem;
-	    }
+}
-	    if ((dividend ^ divisor) < 0) {
+if ((dividend ^ divisor) < 0) {
-		/* different signs, so division would have returned a
+/* different signs, so division would have returned a
-		 * negative number.
+* negative number.
-		 * C rounds toward zero, this code will simulate
+* C rounds toward zero, this code will simulate
-		 * rounding towards negative infinity.
+* rounding towards negative infinity.
-		 */
+*/
-		rem = divisor - rem;
+rem = divisor - rem;
-	    }
+}
-	}
+}
-	RETURN ( __mkSmallInteger(rem) );
+RETURN ( __mkSmallInteger(rem) );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 (aNumber = 0) ifTrue:[
-	^ ZeroDivide raiseRequestWith:thisContext.
+^ ZeroDivide raiseRequestWith:thisContext.
 ].
 ^ aNumber moduloFromInteger:self
 "
 9 \\ 4  == 1 ifFalse:[self halt].
 return context._RETURN( self.abs());
 #else
 INT val = __intVal(self);
 if (val >= 0) {
-	RETURN (self);
+RETURN (self);
 }
 if (val != _MIN_INT) {
-	RETURN ( __mkSmallInteger(-val) );
+RETURN ( __mkSmallInteger(-val) );
 }
 /* only reached for minVal */
 RETURN( __MKLARGEINT(-_MIN_INT));
 #endif
 %}.
 quo:aNumber
 "return the integer part of the quotient of the receiver's value
 and the argument's value. The result is truncated towards zero
 and negative, if the operands signs differ..
 The following is always true:
-	(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
+(receiver quo: aNumber) * aNumber + (receiver rem: aNumber) = receiver
 For positive results, this is the same as #//,
 for negative results, the remainder is ignored.
 I.e.: '9 // 4 = 2' and '-9 // 4 = -3'
 in contrast: '9 quo: 4 = 2' and '-9 quo: 4 = -2'"
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 return context._RETURN( self.quotient(aNumber));
 #else
 if (__isSmallInteger(aNumber)) {
-	INT val = __intVal(aNumber);
+INT val = __intVal(aNumber);
-	if (val != 0) {
+if (val != 0) {
-	    RETURN ( __mkSmallInteger(__intVal(self) / val) );
+RETURN ( __mkSmallInteger(__intVal(self) / val) );
-	}
+}
 } else {
-	if (__isFractionLike(aNumber)) {
+if (__isFractionLike(aNumber)) {
-	    OBJ t = __FractionInstPtr(aNumber)->f_numerator;
+OBJ t = __FractionInstPtr(aNumber)->f_numerator;
-	    if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-		INT num = __intVal(t);
+INT num = __intVal(t);
-		t = __FractionInstPtr(aNumber)->f_denominator;
+t = __FractionInstPtr(aNumber)->f_denominator;
-		if (__isSmallInteger(t)) {
+if (__isSmallInteger(t)) {
-		    INT den = __intVal(t);
+INT den = __intVal(t);
-		    INT myself = __intVal(self);
+INT myself = __intVal(self);
-		    INT prod;
+INT prod;
 #if 0 && defined(__GNUC__) // supported from GCC 5
-		    if (__builtin_mul_overflow(myself, den, &prod)) {
+if (__builtin_mul_overflow(myself, den, &prod)) {
-			RETURN ( __mkSmallInteger(prod / num ));
+RETURN ( __mkSmallInteger(prod / num ));
-		    }
+}
 #else
-		    prod = myself * den;
+prod = myself * den;
-		    // make sure, that no overflow occurred
+// make sure, that no overflow occurred
-		    if (prod / den == myself) {
+if (prod / den == myself) {
-			RETURN ( __mkSmallInteger(prod / num ));
+RETURN ( __mkSmallInteger(prod / num ));
-		    }
+}
 #endif
-		}
+}
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 (aNumber = 0) ifTrue:[
-	^ ZeroDivide raiseRequestWith:thisContext.
+^ ZeroDivide raiseRequestWith:thisContext.
 ].
 ^ self retry:#quo: coercing:aNumber
 "
 9 // 4
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitAnd(anInteger));
 #else
 /* anding the tags doesn't change it */
 if (__isSmallInteger(anInteger)) {
-	RETURN ( ((OBJ) ((INT)self & (INT)anInteger)) );
+RETURN ( ((OBJ) ((INT)self & (INT)anInteger)) );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 anInteger class == LargeInteger ifTrue:[
-	^ anInteger bitAnd:self
+^ anInteger bitAnd:self
 ].
 ^ self retry:#bitAnd: coercing:anInteger
 "(2r001010100 bitAnd:2r00001111) radixPrintStringRadix:2"
 !
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitClear(anInteger));
 #else
 /* anding the tags doesn't change it */
 if (__isSmallInteger(anInteger)) {
-	RETURN ( ((OBJ) (((INT)self & ~(INT)anInteger) | TAG_INT)) );
+RETURN ( ((OBJ) (((INT)self & ~(INT)anInteger) | TAG_INT)) );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ self retry:#bitClear: coercing:anInteger
 unsigned INT _self = __intVal(self);
 _cnt = 0;
 while (_self) {
-	_cnt++;
+_cnt++;
-	_self = _self & (_self - 1);
+_self = _self & (_self - 1);
 }
 # else
 #  ifdef ALGORITHM_2
 // seems to be faster on the average (and has better worst case)
 static unsigned char table[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
 unsigned INT _self = __intVal(self);
 _cnt = 0;
 while (_self) {
-	_cnt += table[ _self & 0x0F ];
+_cnt += table[ _self & 0x0F ];
-	_self >>= 4;
+_self >>= 4;
 }
 #  else
 #   ifdef ALGORIHTM_3
 // the fastest, but hard (impossible) to understand (google for fastest bit count)
 #     if __POINTER_SIZE__ == 8
 unsigned INT _v;
 #    define _POPCNT(__op)                      \
 ({                                          \
-	INT __rslt;                             \
+INT __rslt;                             \
-	asm("xor     %%rax,%%rax        \n      \
+asm("xor     %%rax,%%rax        \n      \
-	     popcnt %1,%%rax           \n      \
+popcnt %1,%%rax           \n      \
-			"  : "=a" (__rslt)      \
+"  : "=a" (__rslt)      \
-			   : "g" ((INT)(__op))    \
+: "g" ((INT)(__op))    \
-			   : "cc");             \
+: "cc");             \
-	(OBJ)__rslt;                            \
+(OBJ)__rslt;                            \
 })
 _v = (INT)self;
 _cnt = _POPCNT(_v);
 _cnt--; // one too many due to tag
 #     else
 #    define _POPCNT(__op)                      \
 ({                                          \
-	INT __rslt;                             \
+INT __rslt;                             \
-	asm("xor     %%eax,%%eax        \n      \
+asm("xor     %%eax,%%eax        \n      \
-	     popcnt  %1,%%eax           \n      \
+popcnt  %1,%%eax           \n      \
-			"  : "=a" (__rslt)      \
+"  : "=a" (__rslt)      \
-			   : "g" ((INT)(__v))   \
+: "g" ((INT)(__v))   \
-			   : "cc");             \
+: "cc");             \
-	(OBJ)__rslt;                            \
+(OBJ)__rslt;                            \
 })
 _v = (INT)self;
 _cnt = _POPCNT(_v);
 _cnt--; // one too many due to tag
 ^ super bitCount.
 "
 1 to:1000000 do:[:n |
-	self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))
+self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))
 ].
 #( 16r00000000
-	16r00010000 16r00100000 16r01000000 16r10000000
+16r00010000 16r00100000 16r01000000 16r10000000
-	16r00020000 16r00200000 16r02000000 16r20000000
+16r00020000 16r00200000 16r02000000 16r20000000
-	16r00040000 16r00400000 16r04000000 16r40000000
+16r00040000 16r00400000 16r04000000 16r40000000
-	16r00080000 16r00800000 16r08000000 16r80000000
+16r00080000 16r00800000 16r08000000 16r80000000
-	16rFFFFFFFF 16r7FFFFFFF 16r3FFFFFFF 16r1FFFFFFF
+16rFFFFFFFF 16r7FFFFFFF 16r3FFFFFFF 16r1FFFFFFF
-	16rEEEEEEEE 16r7EEEEEEE 16r3EEEEEEE 16r1EEEEEEE
+16rEEEEEEEE 16r7EEEEEEE 16r3EEEEEEE 16r1EEEEEEE
-	16rDDDDDDDD 16r7DDDDDDD 16r3DDDDDDD 16r1DDDDDDD
+16rDDDDDDDD 16r7DDDDDDD 16r3DDDDDDD 16r1DDDDDDD
-	16rCCCCCCCC 16r7CCCCCCC 16r3CCCCCCC 16r1CCCCCCC
+16rCCCCCCCC 16r7CCCCCCC 16r3CCCCCCC 16r1CCCCCCC
-	16r8000000000010000 16r8000000000100000 16r8000000001000000 16r8000000010000000
+16r8000000000010000 16r8000000000100000 16r8000000001000000 16r8000000010000000
-	16r8000000000020000 16r8000000000200000 16r8000000002000000 16r8000000020000000
+16r8000000000020000 16r8000000000200000 16r8000000002000000 16r8000000020000000
-	16r8000000000040000 16r8000000000400000 16r8000000004000000 16r8000000040000000
+16r8000000000040000 16r8000000000400000 16r8000000004000000 16r8000000040000000
-	16r8000000000080000 16r8000000000800000 16r8000000008000000 16r8000000080000000
+16r8000000000080000 16r8000000000800000 16r8000000008000000 16r8000000080000000
-	16r80000000FFFFFFFF 16r800000007FFFFFFF 16r800000003FFFFFFF 16r800000001FFFFFFF
+16r80000000FFFFFFFF 16r800000007FFFFFFF 16r800000003FFFFFFF 16r800000001FFFFFFF
-	16r80000000EEEEEEEE 16r800000007EEEEEEE 16r800000003EEEEEEE 16r800000001EEEEEEE
+16r80000000EEEEEEEE 16r800000007EEEEEEE 16r800000003EEEEEEE 16r800000001EEEEEEE
-	16r80000000DDDDDDDD 16r800000007DDDDDDD 16r800000003DDDDDDD 16r800000001DDDDDDD
+16r80000000DDDDDDDD 16r800000007DDDDDDD 16r800000003DDDDDDD 16r800000001DDDDDDD
-	16r80000000CCCCCCCC 16r800000007CCCCCCC 16r800000003CCCCCCC 16r800000001CCCCCCC
+16r80000000CCCCCCCC 16r800000007CCCCCCC 16r800000003CCCCCCC 16r800000001CCCCCCC
-	16rFFFFFFFFFFFFFFFF 16r7FFFFFFFFFFFFFFF 16r3FFFFFFFFFFFFFFF 16r1FFFFFFFFFFFFFFF
+16rFFFFFFFFFFFFFFFF 16r7FFFFFFFFFFFFFFF 16r3FFFFFFFFFFFFFFF 16r1FFFFFFFFFFFFFFF
 ) do:[:n |
-	self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))
+self assert:(n bitCount = ((n printStringRadix:2) occurrencesOf:$1))
 ]
 1 to:10000000 do:[:n |
-	(n bitCount)
+(n bitCount)
 ]
 "
 "Modified: / 09-01-2012 / 19:12:41 / cg"
 !
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitOr( anInteger ));
 #else
 /* oring the tags doesn't change it */
 if (__isSmallInteger(anInteger)) {
-	RETURN ( ((OBJ) ((INT)self | (INT)anInteger)) );
+RETURN ( ((OBJ) ((INT)self | (INT)anInteger)) );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ self retry:#bitOr: coercing:anInteger
 // swap 2-byte long pairs
 v = ((v >> 16) & 0x0000FFFF) | ((v & 0x0000FFFF) << 16);
 # endif
 if (v <= _MAX_INT) {
-	RETURN ( __mkSmallInteger(v) );
+RETURN ( __mkSmallInteger(v) );
 }
 RETURN (__MKUINT(v));
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super bitReversed
 v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
 // swap bytes
 v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
 if (v <= _MAX_INT) {
-	RETURN ( __mkSmallInteger(v) );
+RETURN ( __mkSmallInteger(v) );
 }
 RETURN (__MKUINT(v));
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super bitReversed16
 v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
 // swap 2-byte long pairs
 v = ((v >> 16) & 0x0000FFFF) | ((v & 0x0000FFFF) << 16);
 if (v <= _MAX_INT) {
-	RETURN ( __mkSmallInteger(v) );
+RETURN ( __mkSmallInteger(v) );
 }
 RETURN (__MKUINT(v));
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super bitReversed32
 v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
 // swap nibbles ...
 v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
 if (v <= _MAX_INT) {
-	RETURN ( __mkSmallInteger(v) );
+RETURN ( __mkSmallInteger(v) );
 }
 RETURN (__MKUINT(v));
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super bitReversed8
 bitShift:shiftCount
 "return the value of the receiver shifted by shiftCount bits;
 leftShift if shiftCount > 0; rightShift otherwise.
 Notice: the result of bitShift: 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).
-	     However, ST/X preserves the sign."
+However, ST/X preserves the sign."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitShift( shiftCount ));
 #else
 INT bits, count;
 if (__isSmallInteger(shiftCount)) {
-	bits = __intVal(self);
+bits = __intVal(self);
-	if (bits == 0) {
+if (bits == 0) {
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	if (count > 0) {
+if (count > 0) {
-	    INT sign = 1;
+INT sign = 1;
-	    if (bits < 0) {
+if (bits < 0) {
-		bits = -bits;
+bits = -bits;
-		sign = -1;
+sign = -1;
-	    }
+}
-	    /*
+/*
-	     * a left shift
+* a left shift
-	     */
+*/
 # if defined(USE_LONGLONG_FOR_SHIFT)
-	    if (count <= N_INT_BITS) {
+if (count <= N_INT_BITS) {
-		unsigned LONGLONG result;
+unsigned LONGLONG result;
-		result = (unsigned LONGLONG)bits;
+result = (unsigned LONGLONG)bits;
-		result <<= count;
+result <<= count;
-		if (result <= _MAX_INT) {
+if (result <= _MAX_INT) {
-		    if (sign < 0) {
+if (sign < 0) {
-			RETURN ( __MKINT(-result) );
+RETURN ( __MKINT(-result) );
-		    }
+}
-		    RETURN ( __mkSmallInteger(result) );
+RETURN ( __mkSmallInteger(result) );
-		}
+}
-		{
+{
-		    RETURN (__MKLARGEINT64(sign, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
+RETURN (__MKLARGEINT64(sign, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
-		}
+}
-	    }
+}
 # else
-	    /*
+/*
-	     * check for overflow
+* check for overflow
-	     */
+*/
-	    if (count < (N_INT_BITS-1)) {
+if (count < (N_INT_BITS-1)) {
-		if (! (bits >> (N_INT_BITS - 1 - count))) {
+if (! (bits >> (N_INT_BITS - 1 - count))) {
-		    INT result = bits << count;
+INT result = bits << count;
-		    if (sign < 0) {
+if (sign < 0) {
-			RETURN ( __MKINT(-result) );
+RETURN ( __MKINT(-result) );
-		    }
+}
-		    RETURN ( __mkSmallInteger(result) );
+RETURN ( __mkSmallInteger(result) );
-		}
+}
-		/*
+/*
-		 * so, there is an overflow ...
+* so, there is an overflow ...
-		 * handle it as largeInteger
+* handle it as largeInteger
-		 */
+*/
-		/* FALL THROUGH */
+/* FALL THROUGH */
-	    }
+}
 # endif
-	} else {
+} else {
-	    if (count == 0) {
+if (count == 0) {
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    /*
+/*
-	     * right shifts cannot overflow
+* right shifts cannot overflow
-	     *
+*
-	     * some machines ignore shifts bigger than
+* some machines ignore shifts bigger than
-	     * the number of bits in an int ...
+* the number of bits in an int ...
-	     */
+*/
-	    count = -count;
+count = -count;
-	    if (count > (N_INT_BITS-1)) {
+if (count > (N_INT_BITS-1)) {
-		RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	    }
+}
-	    RETURN ( __mkSmallInteger(bits >> count) );
+RETURN ( __mkSmallInteger(bits >> count) );
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 (shiftCount isMemberOf:SmallInteger) ifTrue:[
-	^ (LargeInteger value:self) bitShift:shiftCount
+^ (LargeInteger value:self) bitShift:shiftCount
 ].
 ^ self bitShift:shiftCount asInteger   "/ is this a good idea ?
 !
 bitTest:aMask
 is non-0, false otherwise."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 return context._RETURN(
-	    ( self.bitAnd( aMask ) == STInteger._0 )
+( self.bitAnd( aMask ) == STInteger._0 )
-	    ? STObject.False : STObject.True );
+? STObject.False : STObject.True );
 /* NOTREACHED */
 #else
 /* and all bits except tag */
 if (__isSmallInteger(aMask)) {
-	RETURN ( ((INT)self & ((INT)aMask & ~TAG_MASK)) ? true : false );
+RETURN ( ((INT)self & ((INT)aMask & ~TAG_MASK)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 aMask class == LargeInteger ifTrue:[
-	^ (aMask bitAnd:self) ~~ 0
+^ (aMask bitAnd:self) ~~ 0
 ].
 ^ self retry:#bitTest: coercing:aMask
 "
 2r10001 bitTest:2r00001
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitXor( anInteger ));
 #else
 /* xoring the tags turns it off - or it in again */
 if (__isSmallInteger(anInteger)) {
-	RETURN ( (OBJ)( ((INT)self ^ (INT)anInteger) | TAG_INT) );
+RETURN ( (OBJ)( ((INT)self ^ (INT)anInteger) | TAG_INT) );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ self retry:#bitXor: coercing:anInteger
 !
 Returns 0 if no bit is set."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 {
-	long bits = self.longValue();
+long bits = self.longValue();
-	int bitNr = 0;
+int bitNr = 0;
-	if (bits != 0) {
+if (bits != 0) {
-	    if ((bits & 0xFFFFFFFF00000000L) != 0) {
+if ((bits & 0xFFFFFFFF00000000L) != 0) {
-		bitNr += 32; bits >>= 32;
+bitNr += 32; bits >>= 32;
-	    }
+}
-	    if ((bits & 0xFFFF0000L) != 0) {
+if ((bits & 0xFFFF0000L) != 0) {
-		bitNr += 16; bits >>= 16;
+bitNr += 16; bits >>= 16;
-	    }
+}
-	    if ((bits & 0xFF00) != 0) {
+if ((bits & 0xFF00) != 0) {
-		bitNr += 8; bits >>= 8;
+bitNr += 8; bits >>= 8;
-	    }
+}
-	    if ((bits & 0xF0) != 0) {
+if ((bits & 0xF0) != 0) {
-		bitNr += 4; bits >>= 4;
+bitNr += 4; bits >>= 4;
-	    }
+}
-	    if ((bits & 0xC) != 0) {
+if ((bits & 0xC) != 0) {
-		bitNr += 2; bits >>= 2;
+bitNr += 2; bits >>= 2;
-	    }
+}
-	    if ((bits & 0x2) != 0) {
+if ((bits & 0x2) != 0) {
-		bitNr += 1; bits >>= 1;
+bitNr += 1; bits >>= 1;
-	    }
+}
-	    bitNr += 1;
+bitNr += 1;
-	}
+}
-	return context._RETURN( STInteger._new(bitNr) );
+return context._RETURN( STInteger._new(bitNr) );
 }
 /* NOTREACHED */
 #else
 unsigned INT bits;
 int index;
 bits = __intVal(self);
 if (bits == 0) {
-	RETURN ( __mkSmallInteger(0) );
+RETURN ( __mkSmallInteger(0) );
 }
 # ifdef __BSR
 /*
 * so much for CISC CPUS:
 index = 0;
 #  if __POINTER_SIZE__ == 8
 if (bits & 0xFFFFFFFF00000000L) {
-	index += 32; bits >>= 32;
+index += 32; bits >>= 32;
 }
 #  endif
 if (bits & 0xFFFF0000L) {
-	index += 16; bits >>= 16;
+index += 16; bits >>= 16;
 }
 if (bits & 0xFF00) {
-	index += 8; bits >>= 8;
+index += 8; bits >>= 8;
 }
 if (bits & 0xF0) {
-	index += 4; bits >>= 4;
+index += 4; bits >>= 4;
 }
 if (bits & 0xC) {
-	index += 2; bits >>= 2;
+index += 2; bits >>= 2;
 }
 if (bits & 0x2) {
-	index += 1; bits >>= 1;
+index += 1; bits >>= 1;
 }
 # endif /* no BSR instruction */
 RETURN ( __mkSmallInteger(index+1) );
 #endif /* not __SCHTEAM__ */
 2r100 highBit
 2r1000 highBit
 2r100000000000 highBit
 ((0 to:64) collect:[:s | 1 bitShift:s])
-	collect:[:n | n highBit]
+collect:[:n | n highBit]
 (((0 to:64) collect:[:s | 1 bitShift:s])
-	collect:[:n | n highBit]) = (1 to:65)
+collect:[:n | n highBit]) = (1 to:65)
 "
 "
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r1 highBit
+2r1 highBit
-	]
+]
 ]
 "
 "
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r1111 highBit
+2r1111 highBit
-	]
+]
 ]
 "
 "
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r11111111111111 highBit
+2r11111111111111 highBit
-	]
+]
 ]
 "
 "
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r11111111111111111111111111 highBit
+2r11111111111111111111111111 highBit
-	]
+]
 ]
 "
 "
 2r000100 highBit
 #ifdef __SCHTEAM__
 long bits = self.longValue();
 int index = 0;
 if (bits != 0) {
-	if ((bits & 0xFFFFFFFFL)==0) {
+if ((bits & 0xFFFFFFFFL)==0) {
-	    index += 32; bits >>= 32;
+index += 32; bits >>= 32;
-	}
+}
-	if ((bits & 0xFFFFL)==0) {
+if ((bits & 0xFFFFL)==0) {
-	    index += 16; bits >>= 16;
+index += 16; bits >>= 16;
-	}
+}
-	if ((bits & 0xFFL)==0) {
+if ((bits & 0xFFL)==0) {
-	    index += 8; bits >>= 8;
+index += 8; bits >>= 8;
-	}
+}
-	if ((bits & 0xFL)==0) {
+if ((bits & 0xFL)==0) {
-	    index += 4; bits >>= 4;
+index += 4; bits >>= 4;
-	}
+}
-	if ((bits & 0x3L)==0) {
+if ((bits & 0x3L)==0) {
-	    index += 2; bits >>= 2;
+index += 2; bits >>= 2;
-	}
+}
-	if ((bits & 0x1L)==0) {
+if ((bits & 0x1L)==0) {
-	    index += 1;
+index += 1;
-	}
+}
 }
 return __c__._RETURN( STInteger._qnew( index ) );
 #else
 unsigned INT bits;
 int index;
 bits = __intVal(self);
 if (bits == 0) {
-	RETURN ( __mkSmallInteger(0) );
+RETURN ( __mkSmallInteger(0) );
 }
 # ifdef __BSF
 /*
 * so much for CISC CPUS:
 index = 1;
 #  if __POINTER_SIZE__ == 8
 if ((bits<<32) == 0) {
-	index += 32; bits >>= 32;
+index += 32; bits >>= 32;
 }
 #  endif
 if ((bits & 0xFFFF)==0) {
-	index += 16; bits >>= 16;
+index += 16; bits >>= 16;
 }
 if ((bits & 0xFF)==0) {
-	index += 8; bits >>= 8;
+index += 8; bits >>= 8;
 }
 if ((bits & 0xF)==0) {
-	index += 4; bits >>= 4;
+index += 4; bits >>= 4;
 }
 if ((bits & 0x3)==0) {
-	index += 2; bits >>= 2;
+index += 2; bits >>= 2;
 }
 if ((bits & 0x1)==0) {
-	index += 1;
+index += 1;
 }
 # endif
 RETURN ( __mkSmallInteger(index) );
 #endif /* not __SCHTEAM__ */
 16r1000 lowBit
 16r1000000 lowBit
 16r1000000000000000 lowBit
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r1000 lowBit
+2r1000 lowBit
-	]
+]
 ]
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r11110000000 lowBit
+2r11110000000 lowBit
-	]
+]
 ]
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r1000000000000 lowBit
+2r1000000000000 lowBit
-	]
+]
 ]
 Time millisecondsToRun:[
-	1000000 timesRepeat:[
+1000000 timesRepeat:[
-	    2r1000000000000000000000000000 lowBit
+2r1000000000000000000000000000 lowBit
-	]
+]
 ]
 "
 !
 rightShift:shiftCount
 "return the value of the receiver shifted by shiftCount bits;
 right shift if shiftCount > 0; left shift  otherwise.
 Notice: the result of bitShift: 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).
-	     However, ST/X preserves the sign."
+However, ST/X preserves the sign."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 #else
 INT bits, count;
 if (__isSmallInteger(shiftCount)) {
-	bits = __intVal(self);
+bits = __intVal(self);
-	if (bits == 0) {
+if (bits == 0) {
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	if (count < 0) {
+if (count < 0) {
-	    /*
+/*
-	     * a left shift
+* a left shift
-	     */
+*/
-	    count = -count;
+count = -count;
 # if defined(USE_LONGLONG_FOR_SHIFT)
-	    if (count <= N_INT_BITS) {
+if (count <= N_INT_BITS) {
-		unsigned LONGLONG result;
+unsigned LONGLONG result;
-		result = (unsigned LONGLONG)bits;
+result = (unsigned LONGLONG)bits;
-		result <<= count;
+result <<= count;
-		if (result <= _MAX_INT) {
+if (result <= _MAX_INT) {
-		    RETURN ( __mkSmallInteger(result) );
+RETURN ( __mkSmallInteger(result) );
-		}
+}
-		{
+{
-		    RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
+RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
-		}
+}
-	    }
+}
 # else
-	    /*
+/*
-	     * check for overflow
+* check for overflow
-	     */
+*/
-	    if (count < (N_INT_BITS-1)) {
+if (count < (N_INT_BITS-1)) {
-		if (! (bits >> (N_INT_BITS - 1 - count))) {
+if (! (bits >> (N_INT_BITS - 1 - count))) {
-		    RETURN ( __mkSmallInteger(bits << count) );
+RETURN ( __mkSmallInteger(bits << count) );
-		}
+}
-		/*
+/*
-		 * so, there is an overflow ...
+* so, there is an overflow ...
-		 * handle it as largeInteger
+* handle it as largeInteger
-		 */
+*/
-		/* FALL THROUGH */
+/* FALL THROUGH */
-	    }
+}
 # endif
-	} else {
+} else {
-	    if (count == 0) {
+if (count == 0) {
-		RETURN (self);
+RETURN (self);
-	    }
+}
-	    /*
+/*
-	     * right shifts cannot overflow
+* right shifts cannot overflow
-	     *
+*
-	     * some machines ignore shifts bigger than
+* some machines ignore shifts bigger than
-	     * the number of bits in an int ...
+* the number of bits in an int ...
-	     */
+*/
-	    if (count > (N_INT_BITS-1)) {
+if (count > (N_INT_BITS-1)) {
-		RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	    }
+}
-	    RETURN ( __mkSmallInteger(bits >> count) );
+RETURN ( __mkSmallInteger(bits >> count) );
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 (shiftCount isMemberOf:SmallInteger) ifTrue:[
-	^ (LargeInteger value:self) rightShift:shiftCount
+^ (LargeInteger value:self) rightShift:shiftCount
 ].
 ^ self rightShift:shiftCount asInteger   "/ is this a good idea ?
 "
-	16 rightShift:2
+16 rightShift:2
-	 4 rightShift:-2
+4 rightShift:-2
 "
 ! !
 !SmallInteger 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 */
 #ifdef __SCHTEAM__
 return context._RETURN( self.bitAt(anIntegerIndex));
 #else
 if (__isSmallInteger(anIntegerIndex)) {
-	INT idx = __smallIntegerVal(anIntegerIndex);
+INT idx = __smallIntegerVal(anIntegerIndex);
-	if (idx > 0) {
+if (idx > 0) {
-	    if (idx > N_INT_BITS) {
+if (idx > N_INT_BITS) {
-		RETURN(__mkSmallInteger(0));
+RETURN(__mkSmallInteger(0));
-	    }
+}
-	    RETURN((__smallIntegerVal(self) & ((INT)1 << (idx-1))) ? __mkSmallInteger(1) : __mkSmallInteger(0));
+RETURN((__smallIntegerVal(self) & ((INT)1 << (idx-1))) ? __mkSmallInteger(1) : __mkSmallInteger(0));
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ SubscriptOutOfBoundsError
-	    raiseRequestWith:anIntegerIndex
+raiseRequestWith:anIntegerIndex
-	    errorString:'index out of bounds'
+errorString:'index out of bounds'
 "
 16r000000001 bitAt:0 -> error
 16r000000001 bitAt:1
 16r000000001 bitAt:2
 " Smalltalk implementation:
 |mask|
 anIntegerIndex <= 0 ifTrue:[
-	^ SubscriptOutOfBoundsSignal
+^ SubscriptOutOfBoundsSignal
-		raiseRequestWith:anIntegerIndex
+raiseRequestWith:anIntegerIndex
-		errorString:'index out of bounds'
+errorString:'index out of bounds'
 ].
 (anIntegerIndex > SmallInteger maxBits) ifTrue:[^ 0].
 mask := 1 bitShift:(anIntegerIndex - 1).
 ((self bitAnd:mask) == 0) ifTrue:[^ 0].
 ^ 1
 but a new number is returned. Should be named #withBitCleared:"
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(anInteger)) {
-	int index = __intVal(anInteger);
+int index = __intVal(anInteger);
-	if (index > 0) {
+if (index > 0) {
 # if __POINTER_SIZE__ == 8
-	    if (index <= 62)
+if (index <= 62)
 # else
-	    if (index <= 30)
+if (index <= 30)
 # endif
-	    {
+{
-		INT mask = __MASKSMALLINT( ((INT)1 << (index-1)));
+INT mask = __MASKSMALLINT( ((INT)1 << (index-1)));
-		RETURN ( ((OBJ) ((INT)self & ~(INT)mask)) );
+RETURN ( ((OBJ) ((INT)self & ~(INT)mask)) );
-	    }
+}
-	    RETURN (self);  /* nothing to do ... */
+RETURN (self);  /* nothing to do ... */
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super clearBit:anInteger
 but a new number is returned. Should be named #withBitInverted:"
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(anInteger)) {
-	int index = __intVal(anInteger);
+int index = __intVal(anInteger);
-	if (index > 0) {
+if (index > 0) {
 # if __POINTER_SIZE__ == 8
-	    if (index <= 62)
+if (index <= 62)
 # else
-	    if (index <= 30)
+if (index <= 30)
 # endif
-	    {
+{
-		INT mask = __MASKSMALLINT((INT)1 << (index-1));
+INT mask = __MASKSMALLINT((INT)1 << (index-1));
-		RETURN ( ((OBJ) ((INT)self ^ (INT)mask)) );
+RETURN ( ((OBJ) ((INT)self ^ (INT)mask)) );
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super invertBit:anInteger
 but a new number is returned. Should be named #withBitSet:"
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(anInteger)) {
-	int index = __intVal(anInteger);
+int index = __intVal(anInteger);
-	if (index > 0) {
+if (index > 0) {
 # if __POINTER_SIZE__ == 8
-	    if (index <= 62)
+if (index <= 62)
 # else
-	    if (index <= 30)
+if (index <= 30)
 # endif
-	    {
+{
-		INT mask = __MASKSMALLINT((INT)1 << (index-1));
+INT mask = __MASKSMALLINT((INT)1 << (index-1));
-		RETURN ( ((OBJ) ((INT)self | (INT)mask)) );
+RETURN ( ((OBJ) ((INT)self | (INT)mask)) );
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super setBit:anInteger
 byteSwapped
 "lsb -> msb;
 i.e. a.b.c.d -> d.c.b.a"
 SmallInteger maxBytes == 8 ifTrue:[
-	^ self byteSwapped64
+^ self byteSwapped64
 ] ifFalse:[
-	^ self byteSwapped32
+^ self byteSwapped32
 ].
 "
 16r11223344 byteSwapped hexPrintString
 16r44332211 byteSwapped hexPrintString
 #  if defined(USE_BSWAP) && defined(__BORLANDC__)
 #   define HAVE_BSWAP
 _asm {
-	mov eax, v
+mov eax, v
-	bswap eax
+bswap eax
-	mov swapped, eax
+mov swapped, eax
 };
 #  endif
 #  if defined(USE_BSWAP) && defined(__VISUALC__)
 #   define HAVE_BSWAP
 _asm {
-	mov eax, v
+mov eax, v
-	xchg al, ah
+xchg al, ah
-	rol eax, 16
+rol eax, 16
-	xchg al, ah
+xchg al, ah
-	mov swapped, eax
+mov swapped, eax
 };
 #  endif
 #  if defined(USE_BSWAP) && defined(__GNUC__)
 #   define HAVE_BSWAP
 asm("movl %1, %%eax \n\
-	 bswap %%eax    \n\
+bswap %%eax    \n\
-	 movl %%eax, %0 \n\
+movl %%eax, %0 \n\
-	"
+"
-	: "=rm"  (swapped)
+: "=rm"  (swapped)
-	: "rm"   (v));
+: "rm"   (v));
 #  endif
 # endif /* __POINTER_SIZE__ == 4 */
 # if __POINTER_SIZE__ == 8
 v &= 0xFFFFFFFF;
 #  if defined(__x86_64__) && defined(__GNUC__) && !defined(__CLANG__)
 #   define HAVE_BSWAP
 asm("movq %1, %%rax \n\
-	 bswap %%eax    \n\
+bswap %%eax    \n\
-	 movq %%rax, %0 \n\
+movq %%rax, %0 \n\
-	"
+"
-	: "=rm"  (swapped)
+: "=rm"  (swapped)
-	: "rm"   (v));
+: "rm"   (v));
 #  endif
 # endif
 # ifndef HAVE_BSWAP
 swapped = ((v>>24) | ((v>>8)&0xFF00) | ((v & 0xFF00)<<8) | ((v & 0xFF)<<24));
 //   xxxxxxxx 00000000 00000000 00000000 -> 00000000 00000000 00000000 xxxxxxxx
 //            xxxxxxxx                                        xxxxxxxx
 //                     xxxxxxxx                      xxxxxxxx
 //                              xxxxxxxx    xxxxxxxx
 swapped =  (v>>56) | ((v>>40)&0xFF00) | ((v>>24) & 0xFF0000) | ((v>>8) & 0xFF000000)
-		| ((v & 0xFF000000)<<8) | ((v & 0x00FF0000)<<24) | ((v & 0x0000FF00)<<40)
+| ((v & 0xFF000000)<<8) | ((v & 0x00FF0000)<<24) | ((v & 0x0000FF00)<<40)
-		| ((v & 0xFF)<<56);
+| ((v & 0xFF)<<56);
 # endif
 RETURN(__MKUINT( swapped ));
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super byteSwapped64
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 int idx0Based = index.intValue() - 1;
 if (idx0Based <= 7) {
-	long myVal = self.longValue();
+long myVal = self.longValue();
-	if (myVal < 0) {
+if (myVal < 0) {
-	    myVal = -myVal;
+myVal = -myVal;
-	}
+}
-	int byteVal = (int)((myVal >> (idx0Based * 8)) & 0xFF);
+int byteVal = (int)((myVal >> (idx0Based * 8)) & 0xFF);
-	return __c__._RETURN( STInteger._qnew(byteVal) );
+return __c__._RETURN( STInteger._qnew(byteVal) );
 }
 if (idx0Based > 0) {
-	return __c__._RETURN( STInteger._0 );
+return __c__._RETURN( STInteger._0 );
 }
 #else
 REGISTER INT val;
 INT idx;
 if (__isSmallInteger(index)) {
-	val = __intVal(self);
+val = __intVal(self);
-	if (val < 0)
+if (val < 0)
-	    val = -val;
+val = -val;
-	switch (idx = __intVal(index)) {
+switch (idx = __intVal(index)) {
-	    case 1:
+case 1:
-		break;
+break;
-	    case 2:
+case 2:
-		val = (val >> 8);
+val = (val >> 8);
-		break;
+break;
-	    case 3:
+case 3:
-		val = (val >> 16);
+val = (val >> 16);
-		break;
+break;
-	    case 4:
+case 4:
-		val = (val >> 24);
+val = (val >> 24);
-		break;
+break;
 # if __POINTER_SIZE__ == 8
-	    case 5:
+case 5:
-		val = (val >> 32);
+val = (val >> 32);
-		break;
+break;
-	    case 6:
+case 6:
-		val = (val >> 40);
+val = (val >> 40);
-		break;
+break;
-	    case 7:
+case 7:
-		val = (val >> 48);
+val = (val >> 48);
-		break;
+break;
-	    case 8:
+case 8:
-		val = (val >> 56);
+val = (val >> 56);
-		break;
+break;
 # endif
-	    default:
+default:
-		if (idx < 1)
+if (idx < 1)
-		    goto bad;   /* sorry */
+goto bad;   /* sorry */
-		RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	}
+}
-	RETURN ( __mkSmallInteger( val & 0xFF) );
+RETURN ( __mkSmallInteger( val & 0xFF) );
 }
 bad: ;
 #endif /* not __SCHTEAM__ */
 %}.
 index > 0 ifFalse:[
-	"
+"
-	 index less than 1 - not allowed
+index less than 1 - not allowed
-	"
+"
-	^ self primitiveFailed
+^ self primitiveFailed
 ].
 ^ 0
 "
 (16r12345678 digitAt:1) printStringRadix:16
 #ifdef __SCHTEAM__
 int idx0Based = index.intValue() - 1;
 long myVal = self.longValue();
 if (idx0Based <= 7) {
-	int byteVal = (int)((myVal >> (idx0Based * 8)) & 0xFF);
+int byteVal = (int)((myVal >> (idx0Based * 8)) & 0xFF);
-	return __c__._RETURN( STInteger._qnew(byteVal) );
+return __c__._RETURN( STInteger._qnew(byteVal) );
 }
 if (idx0Based > 0) {
-	if (myVal < 0) {
+if (myVal < 0) {
-	    return __c__._RETURN( STInteger._M1 );
+return __c__._RETURN( STInteger._M1 );
-	} else {
+} else {
-	    return __c__._RETURN( STInteger._0 );
+return __c__._RETURN( STInteger._0 );
-	}
+}
 }
 #else
 REGISTER INT val;
 INT idx;
 if (__isSmallInteger(index)) {
-	val = __intVal(self);
+val = __intVal(self);
-	switch (idx = __intVal(index)) {
+switch (idx = __intVal(index)) {
-	    case 1:
+case 1:
-		break;
+break;
-	    case 2:
+case 2:
-		val = (val >> 8);
+val = (val >> 8);
-		break;
+break;
-	    case 3:
+case 3:
-		val = (val >> 16);
+val = (val >> 16);
-		break;
+break;
-	    case 4:
+case 4:
-		val = (val >> 24);
+val = (val >> 24);
-		break;
+break;
 # if __POINTER_SIZE__ == 8
-	    case 5:
+case 5:
-		val = (val >> 32);
+val = (val >> 32);
-		break;
+break;
-	    case 6:
+case 6:
-		val = (val >> 40);
+val = (val >> 40);
-		break;
+break;
-	    case 7:
+case 7:
-		val = (val >> 48);
+val = (val >> 48);
-		break;
+break;
-	    case 8:
+case 8:
-		val = (val >> 56);
+val = (val >> 56);
-		break;
+break;
 # endif
-	    default:
+default:
-		if (idx < 1)
+if (idx < 1)
-		    goto bad;   /* sorry */
+goto bad;   /* sorry */
-		if (val < 0) {
+if (val < 0) {
-		    RETURN (__mkSmallInteger(0xFF));
+RETURN (__mkSmallInteger(0xFF));
-		}
+}
-		RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	}
+}
-	RETURN ( __mkSmallInteger( val & 0xFF) );
+RETURN ( __mkSmallInteger( val & 0xFF) );
 }
 bad: ;
 #endif /* not __SCHTEAM__ */
 %}.
 index > 0 ifFalse:[
-	"
+"
-	 index less than 1 - not allowed
+index less than 1 - not allowed
-	"
+"
-	^ self primitiveFailed
+^ self primitiveFailed
 ].
 ^ 0
 "
 (10 digitByteAt:1) printStringRadix:16
 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)
 "
 self == 0 ifTrue: [
-	^ ByteArray with:0.
+^ ByteArray with:0.
 ].
 self < 0 ifTrue: [
-	absValue := self negated
+absValue := self negated
 ] ifFalse: [
-	absValue := self.
+absValue := self.
 ].
 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.
-			    ]
+]
-			]
+]
-		    ]
+]
-		]
+]
-	    ]
+]
-	]
+]
 ].
 ^ digitByteArray
 "
 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)
 "
 self == 0 ifTrue: [
-	^ ByteArray with:0.
+^ ByteArray with:0.
 ].
 self < 0 ifTrue: [
-	absValue := self negated
+absValue := self negated
 ] ifFalse: [
-	absValue := self.
+absValue := self.
 ].
 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:b2 with:b1
+digitByteArray := ByteArray with:b2 with:b1
-	] 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:b3 with:b2 with:b1
+digitByteArray := ByteArray with:b3 with:b2 with:b1
-	    ] 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:b4 with:b3 with:b2 with:b1
+digitByteArray := ByteArray with:b4 with:b3 with:b2 with:b1
-		] 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:b5.
+digitByteArray at:1 put:b5.
-			digitByteArray at:2 put:b4.
+digitByteArray at:2 put:b4.
-			digitByteArray at:3 put:b3.
+digitByteArray at:3 put:b3.
-			digitByteArray at:4 put:b2.
+digitByteArray at:4 put:b2.
-			digitByteArray at:5 put:b1.
+digitByteArray at:5 put:b1.
-		    ] 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:b6.
+digitByteArray at:1 put:b6.
-			    digitByteArray at:2 put:b5.
+digitByteArray at:2 put:b5.
-			    digitByteArray at:3 put:b4.
+digitByteArray at:3 put:b4.
-			    digitByteArray at:4 put:b3.
+digitByteArray at:4 put:b3.
-			    digitByteArray at:5 put:b2.
+digitByteArray at:5 put:b2.
-			    digitByteArray at:6 put:b1.
+digitByteArray at:6 put:b1.
-			] 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:b7.
+digitByteArray at:1 put:b7.
-				digitByteArray at:2 put:b6.
+digitByteArray at:2 put:b6.
-				digitByteArray at:3 put:b5.
+digitByteArray at:3 put:b5.
-				digitByteArray at:4 put:b4.
+digitByteArray at:4 put:b4.
-				digitByteArray at:5 put:b3.
+digitByteArray at:5 put:b3.
-				digitByteArray at:6 put:b2.
+digitByteArray at:6 put:b2.
-				digitByteArray at:7 put:b1.
+digitByteArray at:7 put:b1.
-			    ] ifFalse:[
+] ifFalse:[
-				digitByteArray := ByteArray new:8.
+digitByteArray := ByteArray new:8.
-				digitByteArray at:1 put:absValue.
+digitByteArray at:1 put:absValue.
-				digitByteArray at:2 put:b7.
+digitByteArray at:2 put:b7.
-				digitByteArray at:3 put:b6.
+digitByteArray at:3 put:b6.
-				digitByteArray at:4 put:b5.
+digitByteArray at:4 put:b5.
-				digitByteArray at:5 put:b4.
+digitByteArray at:5 put:b4.
-				digitByteArray at:6 put:b3.
+digitByteArray at:6 put:b3.
-				digitByteArray at:7 put:b2.
+digitByteArray at:7 put:b2.
-				digitByteArray at:8 put:b1.
+digitByteArray at:8 put:b1.
-			    ]
+]
-			]
+]
-		    ]
+]
-		]
+]
-	    ]
+]
-	]
+]
 ].
 ^ digitByteArray
 "
 long val = self.longValue();
 int offs = 0;
 if (val < 0) val = -val;
 if ((val & 0xFFFFFFFF00000000L) != 0) {
-	val >>= 32;
+val >>= 32;
-	offs = 4;
+offs = 4;
 }
 if ((val & 0xFFFF0000) != 0) {
-	if ((val & 0xFF000000) != 0) {
+if ((val & 0xFF000000) != 0) {
-	    offs += 4;
+offs += 4;
-	} else {
+} else {
-	    offs += 3;
+offs += 3;
-	}
+}
 } else {
-	if ((val & 0x0000FF00)!= 0) {
+if ((val & 0x0000FF00)!= 0) {
-	    offs += 2;
+offs += 2;
-	} else {
+} else {
-	    offs += 1;
+offs += 1;
-	}
+}
 }
 return __c__._RETURN( STInteger._qnew(offs) );
 #else
 INT val = __intVal(self);
 int offs = 0;
 if (val < 0) {
-	val = -val;
+val = -val;
 }
 # if __POINTER_SIZE__ == 8
 if (val & 0xFFFFFFFF00000000L) {
-	val >>= 32;
+val >>= 32;
-	offs = 4;
+offs = 4;
 }
 # endif
 if (val & 0xFFFF0000) {
-	if (val & 0xFF000000) {
+if (val & 0xFF000000) {
-	    RETURN ( __mkSmallInteger(4+offs));
+RETURN ( __mkSmallInteger(4+offs));
-	} else {
+} else {
-	    RETURN ( __mkSmallInteger(3+offs));
+RETURN ( __mkSmallInteger(3+offs));
-	}
+}
 } else {
-	if (val & 0x0000FF00) {
+if (val & 0x0000FF00) {
-	    RETURN ( __mkSmallInteger(2+offs));
+RETURN ( __mkSmallInteger(2+offs));
-	} else {
+} else {
-	    RETURN ( __mkSmallInteger(1+offs));
+RETURN ( __mkSmallInteger(1+offs));
-	}
+}
 }
 #endif /* not SCHTEAM */
 %}.
 ^ self abs highBit - 1 // 8 + 1
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 unsigned INT v = __intVal(self);
 if ((INT)v >= 0) {
-	unsigned INT swapped;
+unsigned INT swapped;
 # if __POINTER_SIZE__ == 8
-	swapped = ((v >> 8) & 0x00FF00FF00FF00FF) | ((v & 0x00FF00FF00FF00FF) << 8);
+swapped = ((v >> 8) & 0x00FF00FF00FF00FF) | ((v & 0x00FF00FF00FF00FF) << 8);
 # else
-	swapped = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
+swapped = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
 # endif /* __POINTER_SIZE__ */
-	//if (__ISVALIDINTEGER(swapped)) {   // sorry, but this does not work here if (INT)swapped would be negative
+//if (__ISVALIDINTEGER(swapped)) {   // sorry, but this does not work here if (INT)swapped would be negative
-	if (swapped <= _MAX_INT) {
+if (swapped <= _MAX_INT) {
-	    RETURN ( __mkSmallInteger(swapped) );
+RETURN ( __mkSmallInteger(swapped) );
-	}
+}
-	RETURN (__MKUINT(swapped));
+RETURN (__MKUINT(swapped));
 }
 #endif
 %}.
 ^ super swapBytes
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 INT i = __intVal(self);
 if (i & 0x800000L) {
-	i = i | ~((INT)0xFFFFFF);
+i = i | ~((INT)0xFFFFFF);
 } else {
-	i = i & 0x7FFFFF;
+i = i & 0x7FFFFF;
 }
 RETURN (__mkSmallInteger(i));
 #endif
 %}.
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 INT i = __intVal(self);
 if (i & 0x80) {
-	i = i | ~((INT)0xFF);
+i = i | ~((INT)0xFF);
 } else {
-	i = i & 0x7F;
+i = i & 0x7F;
 }
 RETURN (__mkSmallInteger(i));
 #endif
 %}.
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 INT i = __intVal(self);
 if (i & 0x80000000L) {
-	i = i | ~((INT)0xFFFFFFFF);
+i = i | ~((INT)0xFFFFFFFF);
 } else {
-	i = i & 0x7FFFFFFFL;
+i = i & 0x7FFFFFFFL;
 }
 RETURN (__MKINT(i));
 #endif
 %}.
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 INT i = __intVal(self);
 if (i & 0x8000) {
-	i = i | ~((INT)0xFFFF);
+i = i | ~((INT)0xFFFF);
 } else {
-	i = i & 0x7FFF;
+i = i & 0x7FFF;
 }
 RETURN (__mkSmallInteger(i));
 #endif
 %}.
 #ifdef __SCHTEAM__
 return context._RETURN( self.ltP( aNumber ));
 #else
 if (__isSmallInteger(aNumber)) {
 # ifdef POSITIVE_ADDRESSES
-	RETURN ( (__intVal(self) < __intVal(aNumber)) ? true : false );
+RETURN ( (__intVal(self) < __intVal(aNumber)) ? true : false );
 # else
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	RETURN ( ((INT)self < (INT)aNumber) ? true : false );
+RETURN ( ((INT)self < (INT)aNumber) ? true : false );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) < __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) < __floatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ aNumber lessFromInteger:self
 "^ self retry:#< coercing:aNumber"
 return context._RETURN( self.leP( aNumber ));
 #else
 if (__isSmallInteger(aNumber)) {
 # ifdef POSITIVE_ADDRESSES
-	RETURN ( (__intVal(self) <= __intVal(aNumber)) ? true : false );
+RETURN ( (__intVal(self) <= __intVal(aNumber)) ? true : false );
 # else
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	RETURN ( ((INT)self <= (INT)aNumber) ? true : false );
+RETURN ( ((INT)self <= (INT)aNumber) ? true : false );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) <= __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) <= __floatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ (self > aNumber) not
 as the receiver, false otherwise"
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 if (aNumber.isNumber()) {
-	return context._RETURN( aNumber.eqvP( self.longValue() ));
+return context._RETURN( aNumber.eqvP( self.longValue() ));
 }
 #else
 if (aNumber == self) {
-	RETURN ( true );
+RETURN ( true );
 }
 if (! __isNonNilObject(aNumber)) {
-	/* a smallint or nil */
+/* a smallint or nil */
-	RETURN ( false );
+RETURN ( false );
 }
 if (__qIsFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) == __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) == __floatVal(aNumber)) ? true : false );
 }
 if (__qIsShortFloat(aNumber)) {
-	RETURN ( ((double)__intVal(self) == __shortFloatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) == __shortFloatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ aNumber equalFromInteger:self
 !
 return context._RETURN( self.gtP( aNumber ));
 #else
 if (__isSmallInteger(aNumber)) {
 # ifdef POSITIVE_ADDRESSES
-	RETURN ( (__intVal(self) > __intVal(aNumber)) ? true : false );
+RETURN ( (__intVal(self) > __intVal(aNumber)) ? true : false );
 # else
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	RETURN ( ((INT)self > (INT)aNumber) ? true : false );
+RETURN ( ((INT)self > (INT)aNumber) ? true : false );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) > __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) > __floatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ (aNumber < self)
 return context._RETURN( self.geP( aNumber ));
 #else
 if (__isSmallInteger(aNumber)) {
 # ifdef POSITIVE_ADDRESSES
-	RETURN ( (__intVal(self) >= __intVal(aNumber)) ? true : false );
+RETURN ( (__intVal(self) >= __intVal(aNumber)) ? true : false );
 # else
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	RETURN ( ((INT)self >= (INT)aNumber) ? true : false );
+RETURN ( ((INT)self >= (INT)aNumber) ? true : false );
 # endif
 }
 if (__isFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) >= __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) >= __floatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ (self < aNumber) not
 |low|
 low := self bitAnd: 16r3FFF.
 ^ (9741 * low
 + ((9741 * (self bitShift: -14) + (101 * low) bitAnd: 16383) * 16384))
-	bitAnd: 16r0FFFFFFF
+bitAnd: 16r0FFFFFFF
 "
 1 hashMultiply
 2 hashMultiply
 3 hashMultiply
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(aNumber)) {
 # if TAG_INT == 1
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	if ((INT)(self) > (INT)(aNumber))
+if ((INT)(self) > (INT)(aNumber))
 # else
-	if (__intVal(self) > __intVal(aNumber))
+if (__intVal(self) > __intVal(aNumber))
 # endif
-	{
+{
-	    RETURN ( self );
+RETURN ( self );
-	}
+}
-	RETURN ( aNumber );
+RETURN ( aNumber );
 }
 if (__isFloatLike(aNumber)) {
-	if ( (double)__intVal(self) > __floatVal(aNumber) ) {
+if ( (double)__intVal(self) > __floatVal(aNumber) ) {
-	    RETURN ( self );
+RETURN ( self );
-	}
+}
-	RETURN ( aNumber );
+RETURN ( aNumber );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 "/ fallback for non-smallInteger argument
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(aNumber)) {
 # if TAG_INT == 1
-	/* tag bit does not change ordering */
+/* tag bit does not change ordering */
-	if ((INT)(self) < (INT)(aNumber))
+if ((INT)(self) < (INT)(aNumber))
 # else
-	if (__intVal(self) < __intVal(aNumber))
+if (__intVal(self) < __intVal(aNumber))
 # endif
-	{
+{
-	    RETURN ( self );
+RETURN ( self );
-	}
+}
-	RETURN ( aNumber );
+RETURN ( aNumber );
 }
 if (__isFloatLike(aNumber)) {
-	if ( (double)__intVal(self) < __floatVal(aNumber) ) {
+if ( (double)__intVal(self) < __floatVal(aNumber) ) {
-	    RETURN ( self );
+RETURN ( self );
-	}
+}
-	RETURN ( aNumber );
+RETURN ( aNumber );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 "/ fallback for non-smallInteger argument
 "return true, if the arguments value is not equal to mine"
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 if (aNumber.isNumber()) {
-	return context._RETURN( (aNumber.isEqv( self.longValue() )) ? STObject.False : STObject.True);
+return context._RETURN( (aNumber.isEqv( self.longValue() )) ? STObject.False : STObject.True);
-	/* NOTREACHED */
+/* NOTREACHED */
 }
 #else
 if (aNumber == self) {
-	RETURN ( false );
+RETURN ( false );
 }
 if (! __isNonNilObject(aNumber)) {
-	/* a smallint or nil */
+/* a smallint or nil */
-	RETURN ( true );
+RETURN ( true );
 }
 if (__qIsFloatLike(aNumber)) {
-	RETURN ( ((double)__intVal(self) != __floatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) != __floatVal(aNumber)) ? true : false );
 }
 if (__qIsShortFloat(aNumber)) {
-	RETURN ( ((double)__intVal(self) != __shortFloatVal(aNumber)) ? true : false );
+RETURN ( ((double)__intVal(self) != __shortFloatVal(aNumber)) ? true : false );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 ^ (self = aNumber) not
 ! !
 REGISTER INT tmp;
 static struct inlineCache blockVal = __ILC0(0);
 tmp = __intVal(self);
 if (tmp > 0) {
-	if (__isBlockLike(aBlock)
+if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(0))) {
+&& (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(0))) {
-	    {
+{
-		REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		/*
+/*
-		 * specially tuned version for compiled blocks,
+* specially tuned version for compiled blocks,
-		 * (the most common case)
+* (the most common case)
-		 */
+*/
-		if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
+if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
 # ifdef PARANOIA
-		 && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
+&& (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
 # endif
-		) {
+) {
 # ifdef NEW_BLOCK_CALL
 #                   define BLOCK_ARG  aBlock
 # else
 #                   define BLOCK_ARG  rHome
-		    REGISTER OBJ rHome;
+REGISTER OBJ rHome;
-		    /*
+/*
-		     * home on stack - no need to refetch
+* home on stack - no need to refetch
-		     */
+*/
-		    rHome = __BlockInstPtr(aBlock)->b_home;
+rHome = __BlockInstPtr(aBlock)->b_home;
-		    if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
+if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
 # endif
-		    {
+{
 # ifdef __UNROLL_LOOPS__
-			/*
+/*
-			 * you are not supposed to program like this - I know what I do
+* you are not supposed to program like this - I know what I do
-			 */
+*/
-			while (tmp > 8) {
+while (tmp > 8) {
-			    if (InterruptPending != nil) goto interrupted0;
+if (InterruptPending != nil) goto interrupted0;
-	continue0:
+continue0:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted1;
+if (InterruptPending != nil) goto interrupted1;
-	continue1:
+continue1:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted2;
+if (InterruptPending != nil) goto interrupted2;
-	continue2:
+continue2:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted3;
+if (InterruptPending != nil) goto interrupted3;
-	continue3:
+continue3:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted4;
+if (InterruptPending != nil) goto interrupted4;
-	continue4:
+continue4:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted5;
+if (InterruptPending != nil) goto interrupted5;
-	continue5:
+continue5:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted6;
+if (InterruptPending != nil) goto interrupted6;
-	continue6:
+continue6:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    if (InterruptPending != nil) goto interrupted7;
+if (InterruptPending != nil) goto interrupted7;
-	continue7:
+continue7:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			    tmp -= 8;
+tmp -= 8;
-			}
+}
 # endif /* __UNROLL_LOOPS__ */
-			do {
+do {
-			    if (InterruptPending != nil) goto interruptedX;
+if (InterruptPending != nil) goto interruptedX;
-	continueX:
+continueX:
-			    (*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			} while(--tmp);
+} while(--tmp);
-			RETURN (self);
+RETURN (self);
-			if (0) {
+if (0) {
 # ifdef __UNROLL_LOOPS__
-			    interrupted0:
+interrupted0:
-						__interruptL(@line); goto continue0;
+__interruptL(@line); goto continue0;
-			    interrupted1:
+interrupted1:
-						__interruptL(@line); goto continue1;
+__interruptL(@line); goto continue1;
-			    interrupted2:
+interrupted2:
-						__interruptL(@line); goto continue2;
+__interruptL(@line); goto continue2;
-			    interrupted3:
+interrupted3:
-						__interruptL(@line); goto continue3;
+__interruptL(@line); goto continue3;
-			    interrupted4:
+interrupted4:
-						__interruptL(@line); goto continue4;
+__interruptL(@line); goto continue4;
-			    interrupted5:
+interrupted5:
-						__interruptL(@line); goto continue5;
+__interruptL(@line); goto continue5;
-			    interrupted6:
+interrupted6:
-						__interruptL(@line); goto continue6;
+__interruptL(@line); goto continue6;
-			    interrupted7:
+interrupted7:
-						__interruptL(@line); goto continue7;
+__interruptL(@line); goto continue7;
 # endif /* __UNROLL_LOOPS__ */
-			    interruptedX:
+interruptedX:
-						__interruptL(@line); goto continueX;
+__interruptL(@line); goto continueX;
-			}
+}
-		    }
+}
-		}
+}
-	    }
+}
 #           undef BLOCK_ARG
 # ifdef NEW_BLOCK_CALL
 #           define BLOCK_ARG  aBlock
 # else
 #           define BLOCK_ARG  (__BlockInstPtr(aBlock)->b_home)
 #           define IBLOCK_ARG (__BlockInstPtr(aBlock)->b_home)
 # endif
-	    /*
+/*
-	     * sorry - must check for the blocks code within the loops;
+* sorry - must check for the blocks code within the loops;
-	     * it could be recompiled or flushed (in the interrupt)
+* it could be recompiled or flushed (in the interrupt)
-	     */
+*/
-	    do {
+do {
-		REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
-		    /*
+/*
-		     * arg is a compiled block with code -
+* arg is a compiled block with code -
-		     * directly call it without going through Block>>value
+* directly call it without going through Block>>value
-		     * however, if there is an interrupt, refetch the code pointer.
+* however, if there is an interrupt, refetch the code pointer.
-		     */
+*/
-		    /* stay here, while no interrupts are pending ... */
+/* stay here, while no interrupts are pending ... */
-		    do {
+do {
-			(*codeVal)(BLOCK_ARG);
+(*codeVal)(BLOCK_ARG);
-			if (InterruptPending != nil) goto outerLoop;
+if (InterruptPending != nil) goto outerLoop;
-		    } while (--tmp);
+} while (--tmp);
-		    RETURN (self);
+RETURN (self);
-		} else {
+} else {
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
+if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
-			/*
+/*
-			 * arg is a compiled block with bytecode -
+* arg is a compiled block with bytecode -
-			 * directly call interpreter without going through Block>>value
+* directly call interpreter without going through Block>>value
-			 */
+*/
-			__interpret(aBlock, 0, nil, IBLOCK_ARG, nil, nil);
+__interpret(aBlock, 0, nil, IBLOCK_ARG, nil, nil);
-		    } else {
+} else {
-			/*
+/*
-			 * arg is something else - call it with #value
+* arg is something else - call it with #value
-			 */
+*/
-			(*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
+(*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
-		    }
+}
-		}
+}
 outerLoop: ;
-	    } while (--tmp);
+} while (--tmp);
 #           undef BLOCK_ARG
 #           undef IBLOCK_ARG
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	/*
+/*
-	 * not a block-like thingy - call it with #value
+* not a block-like thingy - call it with #value
-	 */
+*/
-	do {
+do {
-	    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-	    (*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
+(*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
-	} while(--tmp);
+} while(--tmp);
-	RETURN (self);
+RETURN (self);
 }
 #endif
 %}.
 ^ super timesRepeat:aBlock
 REGISTER INT tmp, step;
 REGISTER INT final;
 static struct inlineCache blockVal = __ILC1(0);
 if (__bothSmallInteger(incr, stop)) {
-	tmp = __intVal(self);
+tmp = __intVal(self);
-	final = __intVal(stop);
+final = __intVal(stop);
-	step = __intVal(incr);
+step = __intVal(incr);
-	if (__isBlockLike(aBlock)
+if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
+&& (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
-	    {
+{
-		REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		/*
+/*
-		 * specially tuned version for static compiled blocks, called with
+* specially tuned version for static compiled blocks, called with
-		 * home on the stack (the most common case)
+* home on the stack (the most common case)
-		 */
+*/
-		if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
+if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
 # ifdef PARANOIA
-		 && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
+&& (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
 # endif
-		) {
+) {
 # ifdef NEW_BLOCK_CALL
 #                   define BLOCK_ARG  aBlock
 # else
 #                   define BLOCK_ARG  rHome
-		    REGISTER OBJ rHome;
+REGISTER OBJ rHome;
-		    rHome = __BlockInstPtr(aBlock)->b_home;
+rHome = __BlockInstPtr(aBlock)->b_home;
-		    if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
+if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
 # endif
-		    {
+{
-			if (step < 0) {
+if (step < 0) {
-			    if (step == -1) {
+if (step == -1) {
-				while (tmp >= final) {
+while (tmp >= final) {
-				    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				    tmp--;
+tmp--;
-				}
+}
-			    } else {
+} else {
-				while (tmp >= final) {
+while (tmp >= final) {
-				    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				    tmp += step;
+tmp += step;
-				}
+}
-			    }
+}
-			} else {
+} else {
-			    if (step == 1) {
+if (step == 1) {
-				while (tmp <= final) {
+while (tmp <= final) {
-				    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				    tmp++;
+tmp++;
-				}
+}
-			    } else {
+} else {
-				while (tmp <= final) {
+while (tmp <= final) {
-				    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				    tmp += step;
+tmp += step;
-				}
+}
-			    }
+}
-			}
+}
-			RETURN (self);
+RETURN (self);
-		    }
+}
-		}
+}
-	    }
+}
-	    /*
+/*
-	     * sorry - must check for the blocks code within the loops;
+* sorry - must check for the blocks code within the loops;
-	     * it could be recompiled or flushed (in the interrupt)
+* it could be recompiled or flushed (in the interrupt)
-	     */
+*/
 #           undef BLOCK_ARG
 # ifdef NEW_BLOCK_CALL
 #           define BLOCK_ARG  aBlock
 # else
 #           define BLOCK_ARG  (__BlockInstPtr(aBlock)->b_home)
 #           define IBLOCK_ARG (__BlockInstPtr(aBlock)->b_home)
 # endif
-	    if (step < 0) {
+if (step < 0) {
-		while (tmp >= final) {
+while (tmp >= final) {
-		    REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
-			/*
+/*
-			 * arg is a compiled block with code -
+* arg is a compiled block with code -
-			 * directly call it without going through Block>>value
+* directly call it without going through Block>>value
-			 */
+*/
-			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-		    } else {
+} else {
-			if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
+if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
-			    /*
+/*
-			     * arg is a compiled block with bytecode -
+* arg is a compiled block with bytecode -
-			     * directly call interpreter without going through Block>>value
+* directly call interpreter without going through Block>>value
-			     */
+*/
 # ifdef PASS_ARG_POINTER
-			    {
+{
-				OBJ idx;
+OBJ idx;
-				idx = __mkSmallInteger(tmp);
+idx = __mkSmallInteger(tmp);
-				__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
-			    }
+}
 # else
-			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 # endif
-			} else {
+} else {
-			    /*
+/*
-			     * arg is something else - call it with #value
+* arg is something else - call it with #value
-			     */
+*/
-			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
+(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
-			}
+}
-		    }
+}
-		    tmp += step;
+tmp += step;
-		}
+}
-	    } else {
+} else {
-		while (tmp <= final) {
+while (tmp <= final) {
-		    REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
-			/*
+/*
-			 * arg is a compiled block with code -
+* arg is a compiled block with code -
-			 * directly call it without going through Block>>value
+* directly call it without going through Block>>value
-			 */
+*/
-			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-		    } else {
+} else {
-			if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
+if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
-			    /*
+/*
-			     * arg is a compiled block with bytecode -
+* arg is a compiled block with bytecode -
-			     * directly call interpreter without going through Block>>value
+* directly call interpreter without going through Block>>value
-			     */
+*/
 # ifdef PASS_ARG_POINTER
-			    {
+{
-				OBJ idx;
+OBJ idx;
-				idx = __mkSmallInteger(tmp);
+idx = __mkSmallInteger(tmp);
-				__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
-			    }
+}
 # else
-			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 # endif
-			} else {
+} else {
-			    /*
+/*
-			     * arg is something else - call it with #value:
+* arg is something else - call it with #value:
-			     */
+*/
-			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
+(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
-			}
+}
-		    }
+}
-		    tmp += step;
+tmp += step;
-		}
+}
-	    }
+}
 #           undef BLOCK_ARG
 #           undef IBLOCK_ARG
-	} else {
+} else {
-	    /*
+/*
-	     * arg is something else - call it with #value:
+* arg is something else - call it with #value:
-	     */
+*/
-	    if (step < 0) {
+if (step < 0) {
-		while (tmp >= final) {
+while (tmp >= final) {
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    (*blockVal.ilc_func)(aBlock,
+(*blockVal.ilc_func)(aBlock,
-					 @symbol(value:),
+@symbol(value:),
-					 nil, &blockVal,
+nil, &blockVal,
-					 __mkSmallInteger(tmp));
+__mkSmallInteger(tmp));
-		    tmp += step;
+tmp += step;
-		}
+}
-	    } else {
+} else {
-		while (tmp <= final) {
+while (tmp <= final) {
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    (*blockVal.ilc_func)(aBlock,
+(*blockVal.ilc_func)(aBlock,
-					 @symbol(value:),
+@symbol(value:),
-					 nil, &blockVal,
+nil, &blockVal,
-					 __mkSmallInteger(tmp));
+__mkSmallInteger(tmp));
-		    tmp += step;
+tmp += step;
-		}
+}
-	    }
+}
-	}
+}
-	RETURN ( self );
+RETURN ( self );
 }
 #endif
 %}.
 "/
 "/ arrive here if stop is not a smallInteger
 REGISTER INT tmp;
 INT final;
 static struct inlineCache blockVal = __ILC1(0);
 if (__isSmallInteger(stop)) {
-	tmp = __intVal(self);
+tmp = __intVal(self);
-	final = __intVal(stop);
+final = __intVal(stop);
-	if (__isBlockLike(aBlock)
+if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
+&& (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
-	    {
+{
-		/*
+/*
-		 * specially tuned version for the most common case,
+* specially tuned version for the most common case,
-		 * where called with home on the stack
+* where called with home on the stack
-		 */
+*/
-		REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
 # ifdef NEW_BLOCK_CALL
 #                   define BLOCK_ARG  aBlock
 # else
 #                   define BLOCK_ARG  rHome
-		    REGISTER OBJ rHome;
+REGISTER OBJ rHome;
-		    rHome = __BlockInstPtr(aBlock)->b_home;
+rHome = __BlockInstPtr(aBlock)->b_home;
-		    if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
+if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE))
 # endif
-		    {
+{
 # ifdef PARANOIA
-			if (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
+if (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
 # endif
-			{
+{
-			    /*
+/*
-			     * static compiled blocks ...
+* static compiled blocks ...
-			     */
+*/
 # ifdef __UNROLL_LOOPS__
-			    /*
+/*
-			     * The following code is designed to run as fast as possible;
+* The following code is designed to run as fast as possible;
-			     *  - taken branches only if interrupts are pending
+*  - taken branches only if interrupts are pending
-			     *  - only forward branches (which are usually predicted as not taken)
+*  - only forward branches (which are usually predicted as not taken)
-			     *  - unrolled the loop
+*  - unrolled the loop
-			     *
+*
-			     * you are not supposed to program like this - I know what I do
+* you are not supposed to program like this - I know what I do
-			     */
+*/
 #  if TAG_INT==1
-			    INT t8 = (INT)(__mkSmallInteger(tmp+8));
+INT t8 = (INT)(__mkSmallInteger(tmp+8));
-			    tmp = (INT)(__mkSmallInteger(tmp));
+tmp = (INT)(__mkSmallInteger(tmp));
-			    final = (INT)(__mkSmallInteger(final));
+final = (INT)(__mkSmallInteger(final));
 #  else
-			    INT t8 = tmp+8;
+INT t8 = tmp+8;
 #  endif
-			    for (;;) {
+for (;;) {
-				while (t8 <= final) {
+while (t8 <= final) {
 #  if TAG_INT==1
-				    t8 += (INT)(__MASKSMALLINT(8));
+t8 += (INT)(__MASKSMALLINT(8));
 #  else
-				    t8 += 8;
+t8 += 8;
 #  endif
-				    if (InterruptPending != nil) goto interrupted0;
+if (InterruptPending != nil) goto interrupted0;
-	continue0:
+continue0:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp);
+(*codeVal)(BLOCK_ARG, tmp);
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 #  endif
-				    if (InterruptPending != nil) goto interrupted1;
+if (InterruptPending != nil) goto interrupted1;
-	continue1:
+continue1:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(1)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(1)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+1));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+1));
 #  endif
-				    if (InterruptPending != nil) goto interrupted2;
+if (InterruptPending != nil) goto interrupted2;
-	continue2:
+continue2:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(2)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(2)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+2));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+2));
 #  endif
-				    if (InterruptPending != nil) goto interrupted3;
+if (InterruptPending != nil) goto interrupted3;
-	continue3:
+continue3:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(3)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(3)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+3));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+3));
 #  endif
-				    if (InterruptPending != nil) goto interrupted4;
+if (InterruptPending != nil) goto interrupted4;
-	continue4:
+continue4:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(4)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(4)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+4));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+4));
 #  endif
-				    if (InterruptPending != nil) goto interrupted5;
+if (InterruptPending != nil) goto interrupted5;
-	continue5:
+continue5:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(5)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(5)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+5));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+5));
 #  endif
-				    if (InterruptPending != nil) goto interrupted6;
+if (InterruptPending != nil) goto interrupted6;
-	continue6:
+continue6:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(6)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(6)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+6));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+6));
 #  endif
-				    if (InterruptPending != nil) goto interrupted7;
+if (InterruptPending != nil) goto interrupted7;
-	continue7:
+continue7:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(7)) );
+(*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(7)) );
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+7));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+7));
 #  endif
 #  if TAG_INT==1
-				    tmp += (INT)(__MASKSMALLINT(8));
+tmp += (INT)(__MASKSMALLINT(8));
 #  else
-				    tmp += 8;
+tmp += 8;
 #  endif
-				}
+}
-				while (tmp <= final) {
+while (tmp <= final) {
-				    if (InterruptPending != nil) goto interruptedX;
+if (InterruptPending != nil) goto interruptedX;
-	continueX:
+continueX:
 #  if TAG_INT==1
-				    (*codeVal)(BLOCK_ARG, tmp);
+(*codeVal)(BLOCK_ARG, tmp);
-				    tmp += (INT)(__MASKSMALLINT(1));
+tmp += (INT)(__MASKSMALLINT(1));
 #  else
-				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				    tmp++;
+tmp++;
 #  endif
-				}
+}
-				RETURN (self);
+RETURN (self);
-				if (0) {
+if (0) {
-				    /*
+/*
-				     * no discussion about those gotos ...
+* no discussion about those gotos ...
-				     * ... its better for your CPU's pipelines
+* ... its better for your CPU's pipelines
-				     * (if you dont understand why, just dont argue).
+* (if you dont understand why, just dont argue).
-				     */
+*/
-				    interrupted7:
+interrupted7:
-						    __interruptL(@line); goto continue7;
+__interruptL(@line); goto continue7;
-				    interrupted6:
+interrupted6:
-						    __interruptL(@line); goto continue6;
+__interruptL(@line); goto continue6;
-				    interrupted5:
+interrupted5:
-						    __interruptL(@line); goto continue5;
+__interruptL(@line); goto continue5;
-				    interrupted4:
+interrupted4:
-						    __interruptL(@line); goto continue4;
+__interruptL(@line); goto continue4;
-				    interrupted3:
+interrupted3:
-						    __interruptL(@line); goto continue3;
+__interruptL(@line); goto continue3;
-				    interrupted2:
+interrupted2:
-						    __interruptL(@line); goto continue2;
+__interruptL(@line); goto continue2;
-				    interrupted1:
+interrupted1:
-						    __interruptL(@line); goto continue1;
+__interruptL(@line); goto continue1;
-				    interrupted0:
+interrupted0:
-						    __interruptL(@line); goto continue0;
+__interruptL(@line); goto continue0;
-				    interruptedX:
+interruptedX:
-						    __interruptL(@line); goto continueX;
+__interruptL(@line); goto continueX;
-				}
+}
-			    }
+}
 # else
-			    while (tmp <= final) {
+while (tmp <= final) {
-				if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-				(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-				tmp ++;
+tmp ++;
-			    }
+}
-			    RETURN (self);
+RETURN (self);
 # endif /* __UNROLL_LOOPS__ */
-			}
+}
-			/*
+/*
-			 * mhmh - seems to be a block with dynamic code
+* mhmh - seems to be a block with dynamic code
-			 * must refetch, to allow dynamic recompilation or code flush.
+* must refetch, to allow dynamic recompilation or code flush.
-			 */
+*/
-			while (tmp <= final) {
+while (tmp <= final) {
-			    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-			    if ((codeVal = __BlockInstPtr(aBlock)->b_code) == (OBJFUNC)nil) break;
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) == (OBJFUNC)nil) break;
-			    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-			    tmp ++;
+tmp ++;
-			}
+}
-			if (tmp > final) {
+if (tmp > final) {
-			    RETURN (self);
+RETURN (self);
-			}
+}
-		    }
+}
-		}
+}
-	    }
+}
 #           undef BLOCK_ARG
 # ifdef NEW_BLOCK_CALL
 #           define BLOCK_ARG  aBlock
 # else
 #           define BLOCK_ARG  (__BlockInstPtr(aBlock)->b_home)
 #           define IBLOCK_ARG (__BlockInstPtr(aBlock)->b_home)
 # endif
-	    /*
+/*
-	     * sorry - must check for the blocks code within the loops;
+* sorry - must check for the blocks code within the loops;
-	     * it could be recompiled or flushed (in the interrupt)
+* it could be recompiled or flushed (in the interrupt)
-	     */
+*/
-	    while (tmp <= final) {
+while (tmp <= final) {
-		REGISTER OBJFUNC codeVal;
+REGISTER OBJFUNC codeVal;
-		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
-		    /*
+/*
-		     * arg is a compiled block with code -
+* arg is a compiled block with code -
-		     * directly call it without going through Block>>value
+* directly call it without going through Block>>value
-		     */
+*/
-		    /* stay here, while no interrupts are pending ... */
+/* stay here, while no interrupts are pending ... */
-		    do {
+do {
-			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
+(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
-			if (InterruptPending != nil) goto outerLoop;
+if (InterruptPending != nil) goto outerLoop;
-			tmp++;
+tmp++;
-		    } while (tmp <= final);
+} while (tmp <= final);
-		    RETURN (self);
+RETURN (self);
-		} else {
+} else {
-		    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
+if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
-			/*
+/*
-			 * arg is a compiled block with bytecode -
+* arg is a compiled block with bytecode -
-			 * directly call interpreter without going through Block>>value
+* directly call interpreter without going through Block>>value
-			 */
+*/
 # ifdef PASS_ARG_POINTER
-			{
+{
-			    OBJ idx;
+OBJ idx;
-			    idx = __mkSmallInteger(tmp);
+idx = __mkSmallInteger(tmp);
-			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
-			}
+}
 # else
-			__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
+__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 # endif
-		    } else {
+} else {
-			/*
+/*
-			 * arg is something else - call it with #value:
+* arg is something else - call it with #value:
-			 */
+*/
-			(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
+(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
-		    }
+}
-		}
+}
-	    outerLoop: ;
+outerLoop: ;
-		tmp++;
+tmp++;
-	    }
+}
 #           undef BLOCK_ARG
 #           undef IBLOCK_ARG
-	    RETURN (self);
+RETURN (self);
-	}
+}
-	/*
+/*
-	 * arg is something else - call it with #value:
+* arg is something else - call it with #value:
-	 */
+*/
-	while (tmp <= final) {
+while (tmp <= final) {
-	    if (InterruptPending != nil) __interruptL(@line);
+if (InterruptPending != nil) __interruptL(@line);
-	    (*blockVal.ilc_func)(aBlock,
+(*blockVal.ilc_func)(aBlock,
-					 @symbol(value:),
+@symbol(value:),
-					 nil, &blockVal,
+nil, &blockVal,
-					 __mkSmallInteger(tmp));
+__mkSmallInteger(tmp));
-	    tmp++;
+tmp++;
-	}
+}
-	RETURN ( self );
+RETURN ( self );
 }
 #endif /* not __SCHTEAM__ */
 %}.
 "/
 !SmallInteger methodsFor:'misc math'!
 bernoulli
 "returns the nth Bernoulli number.
 The series runs this:
-	 1/6, 1/30, 1/42, 1/30, 5/66, 691/2730, etc
+1/6, 1/30, 1/42, 1/30, 5/66, 691/2730, etc
 Uses a table of the first 20 bernoulli numbers.
 So bernoulli(42) will fail for now.
 Used with taylor series for tan"
 |table p|
 table := #(
-		(1 6)
+(1 6)
-		(-1 30)
+(-1 30)
-		(1 42)
+(1 42)
-		(-1 30)
+(-1 30)
-		(5 66)
+(5 66)
-		(-691 2730)
+(-691 2730)
-		(7 6)
+(7 6)
-		(-3617 510)
+(-3617 510)
-		(43867 798)
+(43867 798)
-		(-174611 330)
+(-174611 330)
-		(854513 138)
+(854513 138)
-		(-236364091 2730)
+(-236364091 2730)
-		(8553103 6)
+(8553103 6)
-		(-23749461029 870)
+(-23749461029 870)
-		(8615841276005 14322)
+(8615841276005 14322)
-		(-7709321041217 510)
+(-7709321041217 510)
-		(2577687858367 6)
+(2577687858367 6)
-		(-26315271553053477373 1919190)
+(-26315271553053477373 1919190)
-		(2929993913841559 6)
+(2929993913841559 6)
-		(-261082718496449122051 13530)
+(-261082718496449122051 13530)
-	      ).
+).
 self even ifTrue:[
-	self == 0 ifTrue:[^1].
+self == 0 ifTrue:[^1].
-	p := table at:(self / 2).
+p := table at:(self / 2).
-	^ Fraction numerator:(p first) denominator:(p second).
+^ Fraction numerator:(p first) denominator:(p second).
 ].
 self == 1 ifTrue:[ ^ (1 / 2) ].
 ^ 0.
 "
 "
 !
 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"
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 INT val, div, mod, mySelf;
 if (__isSmallInteger(aNumber)
 && ((val = __intVal(aNumber)) > 0)
 && ((mySelf = __intVal(self)) >= 0)) {
-	div = mySelf / val;
+div = mySelf / val;
-	mod = mySelf % val;
+mod = mySelf % val;
-	RETURN (__ARRAY_WITH2( __mkSmallInteger(div), __mkSmallInteger(mod)));
+RETURN (__ARRAY_WITH2( __mkSmallInteger(div), __mkSmallInteger(mod)));
 }
 #endif
 %}.
 ^ super divMod:aNumber
 some code. (thanx to MessageTally)"
 %{  /* NOCONTEXT */
 #ifndef __SCHTEAM__
 if (__isSmallInteger(anInteger)) {
-	INT orgArg, ttt, selfInt, orgSelfInt, temp;
+INT orgArg, ttt, selfInt, orgSelfInt, temp;
-	ttt = orgArg = __intVal(anInteger);
+ttt = orgArg = __intVal(anInteger);
-	if (ttt) {
+if (ttt) {
-	    selfInt = orgSelfInt = __intVal(self);
+selfInt = orgSelfInt = __intVal(self);
-	    while (ttt != 0) {
+while (ttt != 0) {
-		temp = selfInt % ttt;
+temp = selfInt % ttt;
-		selfInt = ttt;
+selfInt = ttt;
-		ttt = temp;
+ttt = temp;
-	    }
+}
-	    /*
+/*
-	     * since its not defined in C, what the sign of
+* since its not defined in C, what the sign of
-	     * a modulus result is when the arg is negative,
+* a modulus result is when the arg is negative,
-	     * change it explicitely here ...
+* change it explicitely here ...
-	     */
+*/
-	    if (orgArg < 0) {
+if (orgArg < 0) {
-		/* result should be negative */
+/* result should be negative */
-		if (orgSelfInt > 0) selfInt = -selfInt;
+if (orgSelfInt > 0) selfInt = -selfInt;
-	    } else {
+} else {
-		/* result should be positive */
+/* result should be positive */
-		if (orgSelfInt < 0) selfInt = -selfInt;
+if (orgSelfInt < 0) selfInt = -selfInt;
-	    }
+}
-	    RETURN ( __mkSmallInteger(selfInt) );
+RETURN ( __mkSmallInteger(selfInt) );
-	}
+}
 }
 #endif
 %}.
 ^ super gcd:anInteger
 !
 to print a number/and for conversion to a LargeInteger.
 Implemented that way, to allow for tiny systems (PDAs) without a Float class
 (i.e. without log)."
 self > 0 ifTrue:[
-	self < 10000 ifTrue:[
+self < 10000 ifTrue:[
-	    self < 10 ifTrue:[^ 0].
+self < 10 ifTrue:[^ 0].
-	    self < 100 ifTrue:[^ 1].
+self < 100 ifTrue:[^ 1].
-	    self < 1000 ifTrue:[^ 2].
+self < 1000 ifTrue:[^ 2].
-	    ^ 3
+^ 3
-	].
+].
-	self < 100000000 ifTrue:[
+self < 100000000 ifTrue:[
-	    self < 100000 ifTrue:[^ 4].
+self < 100000 ifTrue:[^ 4].
-	    self < 1000000 ifTrue:[^ 5].
+self < 1000000 ifTrue:[^ 5].
-	    self < 10000000 ifTrue:[^ 6].
+self < 10000000 ifTrue:[^ 6].
-	    ^ 7
+^ 7
-	].
+].
-	self < 1000000000 ifTrue:[^ 8].
+self < 1000000000 ifTrue:[^ 8].
-	SmallInteger maxBytes == 4 ifTrue:[
+SmallInteger maxBytes == 4 ifTrue:[
-	    "/ on a 32 bit machine, SmallInt cannot be larger
+"/ on a 32 bit machine, SmallInt cannot be larger
-	    ^ 9
+^ 9
-	].
+].
-	"/ 64 bit machine
+"/ 64 bit machine
-	self < 100000000000000 ifTrue:[
+self < 100000000000000 ifTrue:[
-	    self < 10000000000 ifTrue:[^ 9].
+self < 10000000000 ifTrue:[^ 9].
-	    self < 100000000000 ifTrue:[^ 10].
+self < 100000000000 ifTrue:[^ 10].
-	    self < 1000000000000 ifTrue:[^ 11].
+self < 1000000000000 ifTrue:[^ 11].
-	    self < 10000000000000 ifTrue:[^ 12].
+self < 10000000000000 ifTrue:[^ 12].
-	    ^ 13
+^ 13
-	].
+].
-	self < 1000000000000000 ifTrue:[^ 14].
+self < 1000000000000000 ifTrue:[^ 14].
-	self < 10000000000000000 ifTrue:[^ 15].
+self < 10000000000000000 ifTrue:[^ 15].
-	self < 100000000000000000 ifTrue:[^ 16].
+self < 100000000000000000 ifTrue:[^ 16].
-	self < 1000000000000000000 ifTrue:[^ 17].
+self < 1000000000000000000 ifTrue:[^ 17].
-	^ 18.
+^ 18.
 ].
 ^ self class
-	raise:#domainErrorSignal
+raise:#domainErrorSignal
-	receiver:self
+receiver:self
-	selector:#intlog10
+selector:#intlog10
-	arguments:#()
+arguments:#()
-	errorString:'logarithm of negative integer'
+errorString:'logarithm of negative integer'
 "
 99 intlog10
 100 intlog10
 101 intlog10
 INT _100s = 0, _10s = 0, _1s = 0;
 INT b = __intVal(self);
 unsigned INT rslt;
 if (b <= 99999999) {
-	if (b <= 255) {
+if (b <= 255) {
-	    // the most common case: convert bytes
+// the most common case: convert bytes
-	    for (i=7; i>=0; i--) {
+for (i=7; i>=0; i--) {
-		if (_100s >= 5)       _100s += 3;
+if (_100s >= 5)       _100s += 3;
-		if (_10s >= 5)        _10s += 3;
+if (_10s >= 5)        _10s += 3;
-		if (_1s >= 5)         _1s += 3;
+if (_1s >= 5)         _1s += 3;
-		_100s    =    (_100s<<1)       | (_10s >> 3 & 1);       _100s &= 0xF;
+_100s    =    (_100s<<1)       | (_10s >> 3 & 1);       _100s &= 0xF;
-		_10s     =    (_10s<<1)        | (_1s >> 3 & 1);        _10s &= 0xF;
+_10s     =    (_10s<<1)        | (_1s >> 3 & 1);        _10s &= 0xF;
-		_1s      =    (_1s<<1)         | (b >> 7 & 1);          _1s &= 0xF;
+_1s      =    (_1s<<1)         | (b >> 7 & 1);          _1s &= 0xF;
-		b <<= 1;
+b <<= 1;
-	    }
+}
-	    rslt = (_100s<<8) | (_10s<<4) | _1s;
+rslt = (_100s<<8) | (_10s<<4) | _1s;
-	    RETURN (__MKSMALLINT( rslt) );
+RETURN (__MKSMALLINT( rslt) );
-	}
+}
-	for (i=26; i>=0; i--) {
+for (i=26; i>=0; i--) {
-	    if (_10000000s >= 5)  _10000000s += 3;
+if (_10000000s >= 5)  _10000000s += 3;
-	    if (_1000000s >= 5)   _1000000s += 3;
+if (_1000000s >= 5)   _1000000s += 3;
-	    if (_100000s >= 5)    _100000s += 3;
+if (_100000s >= 5)    _100000s += 3;
-	    if (_10000s >= 5)     _10000s += 3;
+if (_10000s >= 5)     _10000s += 3;
-	    if (_1000s >= 5)      _1000s += 3;
+if (_1000s >= 5)      _1000s += 3;
-	    if (_100s >= 5)       _100s += 3;
+if (_100s >= 5)       _100s += 3;
-	    if (_10s >= 5)        _10s += 3;
+if (_10s >= 5)        _10s += 3;
-	    if (_1s >= 5)         _1s += 3;
+if (_1s >= 5)         _1s += 3;
-	    _10000000s =  (_10000000s<<1)  | (_1000000s >> 3 & 1);  _10000000s &= 0xF;
+_10000000s =  (_10000000s<<1)  | (_1000000s >> 3 & 1);  _10000000s &= 0xF;
-	    _1000000s =   (_1000000s<<1)   | (_100000s >> 3 & 1);   _1000000s &= 0xF;
+_1000000s =   (_1000000s<<1)   | (_100000s >> 3 & 1);   _1000000s &= 0xF;
-	    _100000s =    (_100000s<<1)    | (_10000s >> 3 & 1);    _100000s &= 0xF;
+_100000s =    (_100000s<<1)    | (_10000s >> 3 & 1);    _100000s &= 0xF;
-	    _10000s  =    (_10000s<<1)     | (_1000s >> 3 & 1);     _10000s &= 0xF;
+_10000s  =    (_10000s<<1)     | (_1000s >> 3 & 1);     _10000s &= 0xF;
-	    _1000s   =    (_1000s<<1)      | (_100s >> 3 & 1);      _1000s &= 0xF;
+_1000s   =    (_1000s<<1)      | (_100s >> 3 & 1);      _1000s &= 0xF;
-	    _100s    =    (_100s<<1)       | (_10s >> 3 & 1);       _100s &= 0xF;
+_100s    =    (_100s<<1)       | (_10s >> 3 & 1);       _100s &= 0xF;
-	    _10s     =    (_10s<<1)        | (_1s >> 3 & 1);        _10s &= 0xF;
+_10s     =    (_10s<<1)        | (_1s >> 3 & 1);        _10s &= 0xF;
-	    _1s      =    (_1s<<1)         | (b >> 26 & 1);         _1s &= 0xF;
+_1s      =    (_1s<<1)         | (b >> 26 & 1);         _1s &= 0xF;
-	    b <<= 1;
+b <<= 1;
-	}
+}
-	rslt = (_10000000s<<28)
+rslt = (_10000000s<<28)
-	       | (_1000000s<<24) | (_100000s<<20) | (_10000s<<16)
+| (_1000000s<<24) | (_100000s<<20) | (_10000s<<16)
-	       | (_1000s<<12) | (_100s<<8) | (_10s<<4) | _1s;
+| (_1000s<<12) | (_100s<<8) | (_10s<<4) | _1s;
-	RETURN (__MKUINT( rslt) );
+RETURN (__MKUINT( rslt) );
 }
 #endif
 %}.
 ^ super asBCD.
 The base argument should be between 2 and 36."
 |absBase|
 (base isInteger and:[absBase := base abs. absBase between:2 and:36]) ifTrue:[
-	showRadix ifTrue:[
+showRadix ifTrue:[
-	    absBase printOn:aStream.
+absBase printOn:aStream.
-	    aStream nextPut:$r.
+aStream nextPut:$r.
-	].
+].
-	aStream nextPutAll:(self printStringRadix:base)
+aStream nextPutAll:(self printStringRadix:base)
 ] ifFalse:[
-	super printOn:aStream base:base showRadix:true.
+super printOn:aStream base:base showRadix:true.
 ].
 "Created: / 07-09-2001 / 13:54:40 / cg"
 "Modified: / 02-08-2010 / 12:25:20 / cg"
 !
 OBJ newString = nil;
 INT myValue;
 int negative = 0;
 if (self == __MKSMALLINT(0)) {
-	RETURN (@global(ZeroString));
+RETURN (@global(ZeroString));
 //        RETURN (__MKSTRING_L("0", 1));
 }
 myValue = __intVal(self);
 if (myValue < 0) {
-	negative = 1;
+negative = 1;
-	myValue = -myValue;
+myValue = -myValue;
 }
 cp = buffer + sizeof(buffer) - 1;
 *cp-- = '\0';
 for ( ; myValue != 0; cp--) {
-	*cp = '0' + (myValue % 10);
+*cp = '0' + (myValue % 10);
-	myValue /= 10;
+myValue /= 10;
 }
 if (negative) {
-	*cp-- = '-';
+*cp-- = '-';
 }
 newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
 if (newString != nil) {
-	RETURN (newString);
+RETURN (newString);
 }
 #endif /* not __SCHTEAM__ */
 %}.
 "/ only arrive here,
 "/  when having memory problems (i.e. no space for string) ...
 int __base = base.intValue().abs();
 long myValue = self.longValue();
 java.lang.String __s;
 switch (__base) {
-	case 2:
+case 2:
-	    __s = java.lang.Long.toBinaryString(myValue);
+__s = java.lang.Long.toBinaryString(myValue);
-	    break;
+break;
-	case 8:
+case 8:
-	    __s = java.lang.Long.toOctalString(myValue);
+__s = java.lang.Long.toOctalString(myValue);
-	    break;
+break;
-	case 10:
+case 10:
-	    __s = java.lang.Long.toString(myValue);
+__s = java.lang.Long.toString(myValue);
-	    break;
+break;
-	case 16:
+case 16:
-	    __s = java.lang.Long.toHexString(myValue);
+__s = java.lang.Long.toHexString(myValue);
-	    break;
+break;
-	default:
+default:
-	{
+{
-	    boolean negative = false;
+boolean negative = false;
-	    __s = "";
+__s = "";
-	    if ((__base > 36) || (__base < 2)) {
+if ((__base > 36) || (__base < 2)) {
-		throw new SmalltalkError("invalid base: ", base);
+throw new SmalltalkError("invalid base: ", base);
-	    }
+}
-	    if (myValue < 0) {
+if (myValue < 0) {
-		negative = true;
+negative = true;
-		myValue = -myValue;
+myValue = -myValue;
-	    }
+}
-	    while (myValue != 0) {
+while (myValue != 0) {
-		int digit;
+int digit;
-		char ch;
+char ch;
-		digit = (int)(myValue % __base);
+digit = (int)(myValue % __base);
-		if (digit <= 9) {
+if (digit <= 9) {
-		    ch = (char)('0' + digit);
+ch = (char)('0' + digit);
-		} else {
+} else {
-		    ch = (char)('A' + digit - 10);
+ch = (char)('A' + digit - 10);
-		}
+}
-		__s = ch + __s;
+__s = ch + __s;
-		myValue = myValue / __base;
+myValue = myValue / __base;
-	    }
+}
-	    if (negative) {
+if (negative) {
-		__s = "-" + __s;
+__s = "-" + __s;
-	    }
+}
-	    break;
+break;
-	}
+}
 }
 return context._RETURN( new STString( __s ));
 #else
 static char ucDigits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 static char lcDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 if (__isSmallInteger(base)) {
-	char *digits;
+char *digits;
-	INT __base;
+INT __base;
-	if (self == __MKSMALLINT(0)) {
+if (self == __MKSMALLINT(0)) {
-	    RETURN (@global(ZeroString));
+RETURN (@global(ZeroString));
-	}
+}
-	__base = __intVal(base);
+__base = __intVal(base);
-	if (__base < 0) {
+if (__base < 0) {
-	    __base = - __base;
+__base = - __base;
-	    digits = lcDigits;
+digits = lcDigits;
-	} else {
+} else {
-	    digits = ucDigits;
+digits = ucDigits;
-	}
+}
-	if ((__base < sizeof(ucDigits)) && (__base > 1)) {
+if ((__base < sizeof(ucDigits)) && (__base > 1)) {
-	    char buffer[64+5];  /* for 64bit machines, base 2, plus sign, plus 0-byte */
+char buffer[64+5];  /* for 64bit machines, base 2, plus sign, plus 0-byte */
-	    char *cp;
+char *cp;
-	    OBJ newString;
+OBJ newString;
-	    int negative = 0;
+int negative = 0;
-	    INT myValue = __intVal(self);
+INT myValue = __intVal(self);
-	    if (myValue < 0) {
+if (myValue < 0) {
-		negative = 1;
+negative = 1;
-		myValue = -myValue;
+myValue = -myValue;
-	    }
+}
-	    cp = buffer + sizeof(buffer) - 1;
+cp = buffer + sizeof(buffer) - 1;
-	    *cp-- = '\0';
+*cp-- = '\0';
-	    for (; myValue != 0; cp--) {
+for (; myValue != 0; cp--) {
-		*cp = digits[myValue % __base];
+*cp = digits[myValue % __base];
-		myValue /= __base;
+myValue /= __base;
-	    }
+}
-	    if (negative) {
+if (negative) {
-		*cp-- = '-';
+*cp-- = '-';
-	    }
+}
-	    newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
+newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
-	    if (newString != nil) {
+if (newString != nil) {
-		RETURN (newString);
+RETURN (newString);
-	    }
+}
-	}
+}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 "/ arrive here, for bad base,
 "/ or when having memory problems (i.e. no space for string) ...
 char buffer[256];
 OBJ s;
 int len;
 if (__isStringLike(formatString)) {
-	/*
+/*
-	 * actually only needed on sparc: since thisContext is
+* actually only needed on sparc: since thisContext is
-	 * in a global register, which gets destroyed by printf,
+* in a global register, which gets destroyed by printf,
-	 * manually save it here - very stupid ...
+* manually save it here - very stupid ...
-	 */
+*/
-	__BEGIN_PROTECT_REGISTERS__
+__BEGIN_PROTECT_REGISTERS__
-	len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __intVal(self));
+len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __intVal(self));
-	__END_PROTECT_REGISTERS__
+__END_PROTECT_REGISTERS__
-	if (len < 0) goto fail;
+if (len < 0) goto fail;
-	s = __MKSTRING_L(buffer, len);
+s = __MKSTRING_L(buffer, len);
-	if (s != nil) {
+if (s != nil) {
-	    RETURN (s);
+RETURN (s);
-	}
+}
 }
 fail: ;
 #endif /* not __SCHTEAM__ */
 %}.
 self primitiveFailed
 "
-	123 printfPrintString:'%%d -> %d'
+123 printfPrintString:'%%d -> %d'
-	123 printfPrintString:'%%6d -> %6d'
+123 printfPrintString:'%%6d -> %6d'
-	123 printfPrintString:'%%x -> %x'
+123 printfPrintString:'%%x -> %x'
-	123 printfPrintString:'%%4x -> %4x'
+123 printfPrintString:'%%4x -> %4x'
-	123 printfPrintString:'%%04x -> %04x'
+123 printfPrintString:'%%04x -> %04x'
 "
 ! !
 !SmallInteger methodsFor:'private'!
 |absVal|
 absVal := self abs.
 aNumber < 0 ifTrue:[
-	^ absVal negated
+^ absVal negated
 ].
 aNumber == 0 ifTrue:[^ 0].
 ^ absVal
 "
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 {
-	long myValue = self.longValue();
+long myValue = self.longValue();
-	long otherValue = aNumber.longValue();
+long otherValue = aNumber.longValue();
-	long sum = myValue + otherValue;
+long sum = myValue + otherValue;
-	return context._RETURN( STInteger._new(sum) );
+return context._RETURN( STInteger._new(sum) );
 }
 /* NOT REACHED */
 #else
 if (__isSmallInteger(aNumber)) {
-	INT sum;
+INT sum;
-	sum =  __intVal(self) + __intVal(aNumber);
+sum =  __intVal(self) + __intVal(aNumber);
-	if (!__ISVALIDINTEGER(sum)) {
+if (!__ISVALIDINTEGER(sum)) {
-	    /* keep the sign */
+/* keep the sign */
-	    sum %= _MAX_INT;
+sum %= _MAX_INT;
-	}
+}
-	RETURN ( __mkSmallInteger(sum));
+RETURN ( __mkSmallInteger(sum));
 }
 #endif
 %}.
 self primitiveFailed
 "
-	5 plus:-1
+5 plus:-1
-	5 plus:1
+5 plus:1
-	1 plus:-5
+1 plus:-5
-	self maxVal plus:1
+self maxVal plus:1
-	self maxVal + 1
+self maxVal + 1
 "
 !
 subtract:aNumber
 "return the difference of the receiver and the argument, as SmallInteger.
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 {
-	long myValue = self.longValue();
+long myValue = self.longValue();
-	long otherValue = aNumber.longValue();
+long otherValue = aNumber.longValue();
-	long diference = myValue - otherValue;
+long diference = myValue - otherValue;
-	return context._RETURN( STInteger._new(diference) );
+return context._RETURN( STInteger._new(diference) );
 }
 /* NOT REACHED */
 #else
 if (__isSmallInteger(aNumber)) {
-	INT diff;
+INT diff;
-	diff = __intVal(self) - __intVal(aNumber);
+diff = __intVal(self) - __intVal(aNumber);
-	if (!__ISVALIDINTEGER(diff)) {
+if (!__ISVALIDINTEGER(diff)) {
-	    /* keep the sign */
+/* keep the sign */
-	    diff %= _MAX_INT;
+diff %= _MAX_INT;
-	}
+}
-	RETURN ( __mkSmallInteger(diff));
+RETURN ( __mkSmallInteger(diff));
 }
 #endif
 %}.
 self primitiveFailed
 "
-	-1 subtract:5
+-1 subtract:5
-	5 subtract:1
+5 subtract:1
-	1 subtract:-5
+1 subtract:-5
-	self minVal subtract:1
+self minVal subtract:1
-	self minVal - 1
+self minVal - 1
 "
 !
 times:aNumber
 "return the product of the receiver and the argument, as SmallInteger.
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 {
-	long myValue = self.longValue();
+long myValue = self.longValue();
-	long otherValue = aNumber.longValue();
+long otherValue = aNumber.longValue();
-	long product = myValue * otherValue;
+long product = myValue * otherValue;
-	return context._RETURN( STInteger._new(product) );
+return context._RETURN( STInteger._new(product) );
 }
 /* NOT REACHED */
 #else
 INT myValue, otherValue;
 unsigned INT productLow, productHi;
 # if defined(__i386__) && defined(__GNUC__) && (__GNUC__ >= 2)
 #  define USE_LONGLONG_FOR_MUL
 # endif
 if (__isSmallInteger(aNumber)) {
-	myValue = __intVal(self);
+myValue = __intVal(self);
-	otherValue = __intVal(aNumber);
+otherValue = __intVal(aNumber);
 # if defined(USE_LONGLONG_FOR_MUL)
-	{
+{
 #  if defined(__alpha__) && !defined(__alpha64__)
 #   define LONGLONG      INT64
 #  else
 #   define LONGLONG      long long
 #  endif
-	    LONGLONG product;
+LONGLONG product;
-	    product = (LONGLONG)myValue * (LONGLONG)otherValue;
+product = (LONGLONG)myValue * (LONGLONG)otherValue;
-	    if (product < 0) {
+if (product < 0) {
-		RETURN ( __mkSmallInteger(-(INT)(-product & _MAX_INT)));
+RETURN ( __mkSmallInteger(-(INT)(-product & _MAX_INT)));
-	    }
+}
-	    RETURN ( __mkSmallInteger((INT)(product & _MAX_INT)));
+RETURN ( __mkSmallInteger((INT)(product & _MAX_INT)));
-	}
+}
 # else /* no long-long */
-	negative = 1;
+negative = 1;
-	if (myValue < 0) {
+if (myValue < 0) {
-	    negative = -1;
+negative = -1;
-	    myValue = -myValue;
+myValue = -myValue;
-	}
+}
-	if (otherValue < 0) {
+if (otherValue < 0) {
-	    negative = -negative;
+negative = -negative;
-	    otherValue = -otherValue;
+otherValue = -otherValue;
-	}
+}
 #  if defined(__GNUC__) && defined(__mc68k__)
-	asm ("mulu%.l %3,%1:%0"
+asm ("mulu%.l %3,%1:%0"
-		: "=d"  ((unsigned long)(productLow)),
+: "=d"  ((unsigned long)(productLow)),
-		  "=d"  ((unsigned long)(productHi))
+"=d"  ((unsigned long)(productHi))
-		: "%0"  ((unsigned long)(myValue)),
+: "%0"  ((unsigned long)(myValue)),
-		  "dmi" ((unsigned long)(otherValue)));
+"dmi" ((unsigned long)(otherValue)));
 #  else
 #   if defined (__GNUC__) && defined(__x86__)
-	asm ("mull %3"
+asm ("mull %3"
-		: "=a"  ((unsigned long)(productLow)),
+: "=a"  ((unsigned long)(productLow)),
-		  "=d"  ((unsigned long)(productHi))
+"=d"  ((unsigned long)(productHi))
-		: "%0"  ((unsigned long)(myValue)),
+: "%0"  ((unsigned long)(myValue)),
-		  "rm"  ((unsigned long)(otherValue)));
+"rm"  ((unsigned long)(otherValue)));
 #   else
 #    if defined(__win32__) && defined(__BORLANDC__)
-	asm {
+asm {
-	    mov   eax, myValue
+mov   eax, myValue
-	    mov   edx, otherValue
+mov   edx, otherValue
-	    mul   edx
+mul   edx
-	    mov   productLow, eax
+mov   productLow, eax
-	    mov   productHi, edx
+mov   productHi, edx
-	}
+}
 #    else /* generic */
-	{
+{
-	    unsigned INT pHH, pHL, pLH, pLL;
+unsigned INT pHH, pHL, pLH, pLL;
-	    unsigned INT low1, low2, hi1, hi2;
+unsigned INT low1, low2, hi1, hi2;
-	    unsigned INT t;
+unsigned INT t;
-	    /* unsigned multiply myValue * otherValue -> productHi, productLow
+/* unsigned multiply myValue * otherValue -> productHi, productLow
-	     *
+*
-	     * this is too slow:
+* this is too slow:
-	     * since most machines can do 32*32 to 64 bit multiply,
+* since most machines can do 32*32 to 64 bit multiply,
-	     * (or at least 32*32 with Overflow check)
+* (or at least 32*32 with Overflow check)
-	     * - need more assembler (inline) functions here
+* - need more assembler (inline) functions here
-	     */
+*/
 #     if __POINTER_SIZE__ == 8
-	    low1 = low32Bits((unsigned INT)myValue);
+low1 = low32Bits((unsigned INT)myValue);
-	    hi1 = hi32Bits((unsigned INT)myValue);
+hi1 = hi32Bits((unsigned INT)myValue);
-	    low2 = low32Bits((unsigned INT)otherValue);
+low2 = low32Bits((unsigned INT)otherValue);
-	    hi2 = hi32Bits((unsigned INT)otherValue);
+hi2 = hi32Bits((unsigned INT)otherValue);
 #      undef LLMASK
 #      define LLMASK 0xC000000000000000LL
 #     else
-	    low1 = low16Bits((unsigned INT)myValue);
+low1 = low16Bits((unsigned INT)myValue);
-	    hi1 = hi16Bits((unsigned INT)myValue);
+hi1 = hi16Bits((unsigned INT)myValue);
-	    low2 = low16Bits((unsigned INT)otherValue);
+low2 = low16Bits((unsigned INT)otherValue);
-	    hi2 = hi16Bits((unsigned INT)otherValue);
+hi2 = hi16Bits((unsigned INT)otherValue);
 #      define LLMASK 0xC0000000
 #     endif
-	    pLH = low1 * hi2;
+pLH = low1 * hi2;
-	    pHL = hi1 * low2;
+pHL = hi1 * low2;
-	    pLL = low1 * low2;
+pLL = low1 * low2;
-	    pHH = hi1 * hi2;
+pHH = hi1 * hi2;
-	    /*
+/*
-	     * the common case ...
+* the common case ...
-	     */
+*/
-	    if ((pHL == 0)
+if ((pHL == 0)
-	     && (pLH == 0)
+&& (pLH == 0)
-	     && (pHH == 0)
+&& (pHH == 0)
-	     && ((pLL & LLMASK) == 0)) {
+&& ((pLL & LLMASK) == 0)) {
-		if (negative < 0) {
+if (negative < 0) {
-		    RETURN ( __mkSmallInteger(- ((INT)pLL)) );
+RETURN ( __mkSmallInteger(- ((INT)pLL)) );
-		}
+}
-		RETURN ( __mkSmallInteger((INT)pLL) );
+RETURN ( __mkSmallInteger((INT)pLL) );
-	    }
+}
-	    /*
+/*
-	     *   pHH |--------|--------|
+*   pHH |--------|--------|
-	     *   pLH          |--------|--------|
+*   pLH          |--------|--------|
-	     *   pHL          |--------|--------|
+*   pHL          |--------|--------|
-	     *   pLL                   |--------|--------|
+*   pLL                   |--------|--------|
-	     */
+*/
 #     if __POINTER_SIZE__ == 8
-	    t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
+t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
-	    productLow = (t << 32) + low32Bits(pLL);
+productLow = (t << 32) + low32Bits(pLL);
-	    productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
+productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
 #     else
-	    t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
+t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
-	    productLow = (t << 16) + low16Bits(pLL);
+productLow = (t << 16) + low16Bits(pLL);
-	    productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
+productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
 #     endif
-	}
+}
 #    endif /* ! __win32__ */
 #   endif /* ! (__GNUC__ && __x86__) */
 #  endif /* ! (__GNUC__ && __mc68k__) */
-	if (negative < 0) {
+if (negative < 0) {
-	    RETURN ( __mkSmallInteger(-(INT)(productLow & _MAX_INT)));
+RETURN ( __mkSmallInteger(-(INT)(productLow & _MAX_INT)));
-	}
+}
-	RETURN ( __mkSmallInteger((INT)(productLow & _MAX_INT)));
+RETURN ( __mkSmallInteger((INT)(productLow & _MAX_INT)));
 # endif /* ! USE_LONGLONG */
 }
 #endif /* not __SCHTEAM__ */
 %}.
 self primitiveFailed
 "
-	5 times:-1
+5 times:-1
-	5 times:1
+5 times:1
-	self maxVal-1 times:2
+self maxVal-1 times:2
-	self maxVal-1 times:-2
+self maxVal-1 times:-2
-	self maxVal-1 * 2  bitAnd:16r3fffffff
+self maxVal-1 * 2  bitAnd:16r3fffffff
 "
 ! !
 !SmallInteger methodsFor:'special modulo bit operators'!
 unsigned INT bits;
 int count;
 if (__isSmallInteger(shiftCount)) {
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	count = count % 32;
+count = count % 32;
-	bits = __intVal(self);
+bits = __intVal(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));
 }
 #endif
 %}.
 ^ self primitiveFailed
 #ifndef __SCHTEAM__
 INT bits, count;
 if (__isSmallInteger(shiftCount)) {
-	count = __intVal(shiftCount);
+count = __intVal(shiftCount);
-	if (count >= 32) {
+if (count >= 32) {
-	    RETURN (__mkSmallInteger(0));
+RETURN (__mkSmallInteger(0));
-	}
+}
-	bits = __intVal(self);
+bits = __intVal(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 (__MKINT(bits));
+RETURN (__MKINT(bits));
 }
 #endif
 %}.
 ^ 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 = __intVal(self);
+bits = __intVal(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));
 }
 #endif
 %}.
 ^ self primitiveFailed
 - reimplemented here for speed"
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 if (STObject.bothSmallInteger(min, max)) {
-	long myVal = ((STInteger)self).longValue();
+long myVal = ((STInteger)self).longValue();
-	if (myVal >= ((STInteger)min).longValue()) {
+if (myVal >= ((STInteger)min).longValue()) {
-	    if (myVal <= ((STInteger)max).longValue()) {
+if (myVal <= ((STInteger)max).longValue()) {
-		return __c__._RETURN_true();
+return __c__._RETURN_true();
-	    }
+}
-	}
+}
-	return __c__._RETURN_false();
+return __c__._RETURN_false();
 }
 #else /* not SCHTEAM */
 if (__bothSmallInteger(min, max)) {
 # if TAG_INT == 1
-	// tag bit does not change the magnitude order
+// tag bit does not change the magnitude order
-	if ((INT)self < (INT)(min)) {
+if ((INT)self < (INT)(min)) {
-	     RETURN ( false );
+RETURN ( false );
-	}
+}
-	if ((INT)self > (INT)(max)) {
+if ((INT)self > (INT)(max)) {
-	     RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN ( true );
+RETURN ( true );
 # else
-	REGISTER INT selfVal;
+REGISTER INT selfVal;
-	selfVal = __intVal(self);
+selfVal = __intVal(self);
-	if (selfVal < __intVal(min)) {
+if (selfVal < __intVal(min)) {
-	     RETURN ( false );
+RETURN ( false );
-	}
+}
-	if (selfVal > __intVal(max)) {
+if (selfVal > __intVal(max)) {
-	     RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN ( true );
+RETURN ( true );
 # endif
 }
 #endif /* not SCHTEAM */
 %}.
 (self < min) ifTrue:[^ false].
 #endif
 %}.
 ^ super parityOdd
 "
-	self assert:
+self assert:
-	 (((0 to:255) collect:[:i | i parityOdd ifTrue:1 ifFalse:0])
+(((0 to:255) collect:[:i | i parityOdd ifTrue:1 ifFalse:0])
-	    asByteArray collect:[:c | c + $0 asciiValue]) asString
+asByteArray collect:[:c | c + $0 asciiValue]) asString
-	 =
+=
-	    '0110100110010110100101100110100110010110011010010110100110010110100101100110100101101001100101100110100110010110100101100110100110010110011010010110100110010110011010011001011010010110011010010110100110010110100101100110100110010110011010010110100110010110'
+'0110100110010110100101100110100110010110011010010110100110010110100101100110100101101001100101100110100110010110100101100110100110010110011010010110100110010110011010011001011010010110011010010110100110010110100101100110100110010110011010010110100110010110'
-	self assert:(16r0FFFFFFF parityOdd = 16r0FFFFFFF bitCount odd).
+self assert:(16r0FFFFFFF parityOdd = 16r0FFFFFFF bitCount odd).
-	self assert:(16r1FFFFFFF parityOdd = 16r1FFFFFFF bitCount odd).
+self assert:(16r1FFFFFFF parityOdd = 16r1FFFFFFF bitCount odd).
-	self assert:(16r3FFFFFFF parityOdd = 16r3FFFFFFF bitCount odd).
+self assert:(16r3FFFFFFF parityOdd = 16r3FFFFFFF bitCount odd).
-	self assert:(16r7FFFFFFF parityOdd = 16r7FFFFFFF bitCount odd).
+self assert:(16r7FFFFFFF parityOdd = 16r7FFFFFFF bitCount odd).
-	self assert:(16rFFFFFFFF parityOdd = 16rFFFFFFFF bitCount odd).
+self assert:(16rFFFFFFFF parityOdd = 16rFFFFFFFF bitCount odd).
-	self assert:(16r3FFFFFFFFFFFFFFF parityOdd = 16r3FFFFFFFFFFFFFFF bitCount odd).
+self assert:(16r3FFFFFFFFFFFFFFF parityOdd = 16r3FFFFFFFFFFFFFFF bitCount odd).
-	self assert:(16r7FFFFFFFFFFFFFFF parityOdd = 16r7FFFFFFFFFFFFFFF bitCount odd).
+self assert:(16r7FFFFFFFFFFFFFFF parityOdd = 16r7FFFFFFFFFFFFFFF bitCount odd).
-	self assert:(16rFFFFFFFFFFFFFFFF parityOdd = 16rFFFFFFFFFFFFFFFF bitCount odd).
+self assert:(16rFFFFFFFFFFFFFFFF parityOdd = 16rFFFFFFFFFFFFFFFF bitCount odd).
 "
 "Modified (comment): / 09-01-2012 / 19:55:37 / cg"
 !

changeset 20339	5d56805b999a
parent 20333	8b2b36463804
child 20346	fd33c56536df
child 20819	b64a4707d4ea